L'Altruiste : Le guide des langages Web

Les composants ActiveX Data Objects (ADO) permettent d'établir une interaction entre une application Web et des sources de données.

Les données représentent principalement le contenu d'un site Internet, et partant, possèdent un intérêt vital auprès des utilisateurs.

Dans le cas d'un site de commerce électronique, la parfaite administration des données constitue un enjeu capital dans la réussite de l'entreprise. En effet, il est nécessaire de mettre à jour régulièrement les données par, la modification des produits, l'ajout de nouveaux ou la suppression d'anciens.

La gestion d'un catalogue important rend obligatoire l'utilisation d'une ou plusieurs sources centralisant l'ensemble des données, indépendamment de la structure de présentation, basée en général sur le langage HTML.

ActiveX Data Objects associé à un langage de script tel que VBScript ou JScript, permettent de construire des applications Web puissantes et interactives, capables de fonctionner avec diverses sources de données, à l'image d'un base de données standards, d'un service d'annuaires ou de courriers électroniques, ou encore d'un système de fichiers.

Le modéle d'objets ADO facilite la gestion des données, en les décomposant en de multiples objets et collections.

Ainsi, un ensemble d'articles pourrait correspondre à un jeu d'enregistrements (objet Recordset), un article à un enregistrement (objet Record), les caractéristiques de ce-dernier à une collection de champs (collection Fields), une caractéristique à un champ (objet Field), etc..

De même, la connexion à une source de données, l'exécution de commandes, un des paramètres de ces dernières, ou encore l'accès au contenu d'un noeud, se traduisent tous par un objet spécifique, en l'occurrence respectivement, les objets Connection, Command, Parameter et Stream.

Une source de données devient ainsi, un ensemble d'objets divers, dont l'accès à chacun est relativement aisé, par l'intermédiaire des composants d'ADO.

Proposant des fonctionnalités combinant le meilleur des différentes techniques d'accès aux sources de données comme ODBC (Open DataBase Connectivity), DAO (Data Access Objects) ou RDO (Remote Data Objects), ADO offre un support universel dans l'échange des données (Universal data Access) pour les besoins actuels comme futurs.

OLE DB (Object Linking and Embedding DataBase) est une interface directe entre des applications COM (Component Object Model) écrites en C++ ou en Java et des sources de données.

Etant un composant COM, ADO ne peut accéder à une source de données que par l'intermédiaire d'OLE DB. Ainsi, une application ASP rédigée en VBScript ou JScript parvient à atteindre une base de données par une première couche spécifique, ADO, qui se charge de traverser l'interface OLE DB pour accéder au but.

Par ailleurs, ADO doit faire appel à un fournisseur correspondant au type d'une source de données et si nécessaire à un pilote ODBC afin d'ouvrir une liaison avec la source de données.

Le fonctionnement d'ADO sur une plateforme nécessite l'installation du composant MDAC (Microsoft® Data Access Components) et pour tirer pleinement parti de l'ensemble des fonctionnalités, l'installation de Visual Basic For Applications ou Visual Studio ou encore Visual C++.

Les objets ADO permettent d'accomplir diverses actions sur des bases de données en utilisant un fournisseur OLE DB (Object Linking Embedding DataBase).

Chacun des objets ADO peuvent être contenus dans leurs collections correspondantes comme Field ou Error dans leur collection respective Fields et Errors.

L'objet ADO Command permet d'exécuter diverses commandes sur des sources de données.

L'objet Command peut appliquer des requêtes sur une base de données et obtenir en retour des enregistrements (record) dans un jeu d'enregistrements (Recordset).

Il est également possible de manipuler la structure d'une base de données par l'intermédiaire de l'objet Command.

Le constructeur ci-dessous permet de créer un objet ADO Command.

Set Objet_Command = Server.CreateObject("ADODB.Command")
'ou
Set Objet_Command = New ADODB.Command

Désormais, il devient possible d'appliquer à cet objet ainsi créé, ses collections, propriétés ou méthodes.

Objet_Command.Collection | Propriété | Méthode

<html>
<head>
<title>Démonstration de Command</title>
<script language="VBScript">
  Sub Soumission_OnClick()
    If Len(formulaire.Nom.value) = 0 Then
    Alert "Veuillez entrer votre nom de famille !"
    formulaire.Nom.focus
    Exit Sub
    ElseIf Len(formulaire.Prenom.value) = 0 Then
    Alert "Veuillez entrer votre prénom !"
    formulaire.Prenom.focus
    Exit Sub
    ElseIf Len(formulaire.Age.value) = 0 Then
    Alert "Veuillez entrer votre âge !"
    formulaire.Age.focus
    Exit Sub
    ElseIf Len(formulaire.Qualite.value) = 0 Then
    Alert "Veuillez entrer votre qualité !"
    formulaire.Qualite.focus
    Exit Sub
    ElseIf Len(formulaire.eMail.value) = 0 Then
    Alert "Veuillez entrer votre adresse email !"
    formulaire.eMail.focus
    Exit Sub
    ElseIf Len(formulaire.Adresse.value) = 0 Then
    Alert "Veuillez entrer votre adresse complète !"
    formulaire.Adresse.focus
    Exit Sub
    End If
    Call formulaire.submit()
  End Sub
</script>
</head>
<body>
<%
  If Len(Request.Form("Etape")) = 0 Then
%>
<form action="command.asp" method="post" name="formulaire">
  <input type="hidden" name="Etape" value="Ajout">
  <table>
    <tr>
    <td>Nom</td>
    <td>
      <input type="text" name="Nom" size="20" value="ANNAIS">
    </td>
    </tr>
    <tr>
    <td>Prénom</td>
    <td>
      <input type="text" name="Prenom" size="20" value="Angélique">
    </td>
    </tr>
    <tr>
    <td>Age</td>
    <td>
      <input type="text" name="Age" size="3" value="23">
    </td>
    </tr>
    <tr>
    <td>Qualité</td>
    <td>
      <input type="text" name="Qualite" size="20" value="Rédacteur">
    </td>
    </tr>
    <tr>
    <td>eMail</td>
    <td>
      <input type="text" name="eMail" size="20" 
                value="angelique.annais@inc.com">
    </td>
    </tr>
    <tr>
    <td>Adresse</td>
    <td>
      <input type="text" name="Adresse" size="20" 
                value="155 Avenue Lingenfield 75000 PARIS">
    </td>
    </tr>
    <tr>
    <td>
      <input type="button" name="Soumission" value="Soumettre">
    </td>
    </tr>
  </table>
</form>
<%
  ElseIf Request.Form("Etape") = "Ajout" Then
  Dim Commande_SQL
  Commande_SQL = "Insert into Fiche (Nom, Prenom, Age, " & _
          "Qualite, eMail, Adresse) Values('" & _
           CStr(Request.Form("Nom")) & "','" & _
           CStr(Request.Form("Prenom")) & "'," & _
           CLng(Request.Form("Age")) & ",'" & _
           CStr(Request.Form("Qualite")) & "','" & _
           CStr(Request.Form("eMail")) & "','" & _
           CStr(Request.Form("Adresse")) & "')"
  Set obj_Connection = Server.CreateObject("ADODB.Connection")
  obj_Connection.Open "DSN=personnel"
  Set obj_Command = Server.CreateObject("ADODB.Command")
  Set obj_Command.ActiveConnection = obj_Connection
  obj_Command.CommandText = Commande_SQL
  obj_Command.CommandType = 1
  obj_Command.Execute
  Response.Write "<p>Les éléments suivants ont été ajoutés à la " & _
                "table de données <i>Personnel</i> :</p>" & _
                "<b>" & Commande_SQL & "</b>"
  Set obj_Command = Nothing
  obj_Connection.Close
  Set obj_Connection = Nothing
  End If
%>
</body>
</html>

L'objet ADO Connection représente un connexion ouverte à une source de données.

Objet_Connection.Collection | Méthode | Propriété | Evénement

Il n'est pas fondamentalement utile de créer un objet Connection pour ouvrir une connexion sur une base de données puisque automatiquement, une ouverture de cete dernière s'opère implicitement, lors de l'utilisation des objets Command, Recordset, et Record.

Outre la connexion à une base de données, l'objet Connection permet de paramètrer précisément des connexions dans le domaine de la sécurité, de la gestion des transactions, du fournisseur OLE DB, etc..

Dépendant des fonctionnalités supportées par le fournisseur, plusieurs collections, méthodes, ou propriétés d'un objet Connection peuvent ne pas être disponibles.

<!-- Formulaire de modification -->
<html>
 <head>
 <script language="VBScript">
     Sub Soumission_OnClick()
       If Len(formulaire.txtNom.value) = 0 Then
       Alert "Veuillez entrer un Nom !"
       formulaire.txtNom.focus
       Exit Sub
       ElseIf Len(formulaire.txtPrenom.value) = 0 Then
       Alert "Veuillez entrer un Prénom !"
       formulaire.txtPrenom.focus
       Exit Sub
       ElseIf Len(formulaire.txtAge.value) = 0 Then
       Alert "Veuillez entrer un âge !"
       formulaire.txtAge.focus
       Exit Sub
       ElseIf Len(formulaire.txtQualite.value) = 0 Then
       Alert "Veuillez entrer une qualité !"
       formulaire.txtQualite.focus
       Exit Sub
       ElseIf Len(formulaire.txtAdresse.value) = 0 Then
       Alert "Veuillez entrer une adresse complète !"
       formulaire.txtAdresse.focus
       Exit Sub
       End If
       Call formulaire.submit()
     End Sub
 </script>
 </head>
 <body>
 <%
     Dim Commande_SQL
     If Len(Request.Form("Etape")) = 0 Then
       Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
       obj_Recordset.Open "Select eMail from Fiche","DSN=Personnel"
 %>
 <form action="traitement.asp" method="post" name="form">
     <input type="hidden" name="Etape" value="Modif">
     <table>
       <tr>
       <th>Sélectionner une adresse eMail</th>
       </tr>
       <tr>
       <td>
         <select name="select_eMail">
         <%
           Do While Not obj_Recordset.EOF
         %>
           <option value="<%=obj_Recordset("eMail")%>">
             <%=obj_Recordset("eMail")%>
           </option>
         <%
             obj_Recordset.MoveNext
           Loop
           obj_Recordset.Close
           Set obj_Recordset = Nothing
         %>
         </select>
       </td>
       </tr>
       <tr>
       <td>
         <input type="submit" name="Validation" value="Soumettre">
       </td>
       </tr>
     </table>
 </form>
 <%
     ElseIf Request.Form("Etape") = "Modif" Then
       Commande_SQL = "Select * from Fiche where eMail = '" & _
                 CStr(Request.Form("select_eMail")) & "'"
       Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
       obj_Recordset.Open strSQL,"DSN=personnel"
 %>
 <form action="connection.asp" method="post" name="formulaire">
     <input type="hidden" name="txtEmail" 
               value="<%=obj_Recordset("eMail")%>">
     <table>
       <tr>
       <td>eMail</td>
       <th style="color: red; font-size:12pt">
         <%=obj_Recordset("eMail")%>
       </th>
       </tr>
       <tr>
       <td>Nom</td>
       <td>
         <input type="text" name="txtNom" size="20"
                  value=<%=obj_Recordset("Nom")%>>
       </td>
       </tr>
       <tr>
       <td>Prenom</td>
       <td>
         <input type="text" name="txtPrenom" size="20"
                  value=<%=obj_Recordset("Prenom")%>>
       </td>
       </tr>
       <tr>
       <td>Age</td>
       <td>
         <input type="text" name="txtAge" size="20"
                  value=<%=obj_Recordset("Age")%>>
       </td>
       </tr>
       <tr>
       <td>Qualité</td>
       <td>
         <input type="text" name="txtQualite" size="20"
                  value=<%=obj_Recordset("Qualite")%>>
       </td>
       </tr>
       <tr>
       <td>Adresse</td>
       <td>
         <textarea name="txtAdresse" cols="20" rows="3">
           <%=obj_Recordset("Adresse")%>
         </textarea>
       </td>
       </tr>
       <tr>
       <td>
         <input type="button" name="Soumission" value="Modifier">
       </td>
       </tr>
     </table>
 </form>
 <%
       obj_Recordset.Close
       Set obj_Recordset = Nothing
     End If
 %>
 </body>
</html>
<!-- Formulaire de traitement traitement.asp -->
<html>
 <body>
 <%
     Dim Commande_SQL
     Dim adCmdText
     adCmdText = 1
     Commande_SQL = "Update Fiche Set " & _
               "Nom = '" & _
               CStr(Request.Form("txtNom")) & "', " & _
               "Prenom = '" & _
               CStr(Request.Form("txtPrenom")) & "', " & _
               "Age = " & _
               CLng(Request.Form("txtAge")) & ", " & _
               "Qualite = '" & _
               CStr(Request.Form("txtQualite")) & "', " & _
               "Adresse = '" & _
               CStr(Request.Form("txtAdresse")) & "' " & _
               "Where eMail = '" & _
               CStr(Request.Form("txtEmail")) & "'"
     Set obj_Connection = Server.CreateObject("ADODB.Connection")
     obj_Connection.Open "DSN=personnel"
     Set obj_Command = Server.CreateObject("ADODB.Command")
     Set obj_Command.ActiveConnection = obj_Connection
     obj_Command.CommandText = Commande_SQL
     obj_Command.CommandType = adCmdText
     obj_Command.Execute
     Response.Write "<p>Les éléments suivants ont été modifiés dans " & _
                   "la table de données <i>Personnel</i> :</p>" & _
                   "<b>" & Commande_SQL & "</b>"
     Set obj_Command = Nothing
     obj_Connection.Close
     Set obj_Connection = Nothing
 %>
 </body>
</html>

Les arguments de la propriété ConnectionString permettent de spécifier plusieurs valeurs à utiliser pour se connecter sur une source de données.

Objet_Connection.ConnectionString = _
                        "Argument=Valeur;...;ArguementN=Valeur"

L'objet ADO Error contient les détails des erreurs d'accès des bases de données qui concerne une unique opération impliquant le fournisseur.

Objet_Error.Propriété

Chaque objet ADO est susceptible de générer une ou plusieurs erreurs spécifiques au fournisseur.

A chaque fois qu'une erreur se produit, un ou plusieurs objets Error sont créés dans la collection Errors de l'objet Connection. Ainsi lorsqu'une opération ADO provoque une autre erreur, la collection Errors est réinitialisée afin d'accueillir le jeu d'erreurs en cours.

Certaines propriétés ou méthodes peuvent retourner des messages d'avertissments qui apparaissent dans la collection Errors à l'image des objets Error. Néanmoins, ces messages n'entraînent pas l'arrêt de l'exécution du programme.

<html>
 <head>
 <%
     Function Verif_coll_Errors(obj_Connection)
     Dim obj_Error
     If Err.Number <> obj_Connection.Errors(0).Number Then
       Exit Function
     End If
     If obj_Connection.Errors.Count > 0 Then
       For Each obj_Error in obj_Connection.Errors
       If obj_Error.Number <> 0 Then
         Response.Write "" & _
           "<table border="0" cellpadding=1 cellspacing=2 border=1>" & _
           "<tr><th>Propriété</th><th>Valeur</th>" & _
           "</tr><tr><th>Numéro</th><td>" & obj_Error.Number & "</td></tr>" & _
           "<tr><th>Erreur native</th><td>" & obj_Error.NativeError & "</td></tr>" & _
           "<tr><th>Etat SQL</th><td>" & obj_Error.SQLState & "</td></tr>" & _
           "<tr><th>Source</th><td>" & obj_Error.Source & "</td></tr>" & _
           "<tr><th>Description</th><td>" & obj_Error.Description & "</td></tr>" & _
           "</table>"
         Verif_coll_Errors = True
       End If
       Next
     Else
       Verif_coll_Errors = False
     End If
     End Function

     On Error Resume Next
 %>
 </head>
 <body>
 <%
     Dim Ch_SQL
     Ch_SQL = "SELECT Noms, Prenom, Age, Qualites, eMail, Adresse" _
            & "FROM Fiche","DSN=personnel"
     Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
     obj_Recordset.Open Ch_SQL
       If Verif_coll_Errors(obj_Recordset.ActiveConnection) = False Then
 %>
       <table border="1" cellpadding="3" align="center">
       <tr>
         <td colspan="6">Fiches signalétiques des personnels</td>
       </tr>
       <tr>
         <td>Nom</td>
         <td>Prénom</td>
         <td>Age</td>
         <td>Qualité</td>
         <td>eMail</td>
         <td>Adresse</td>
       </tr>
 <%
       Do While Not obj_Recordset.EOF
 %>
       <tr>
         <td><%=obj_Recordset("Nom")%></td>
         <td><%=obj_Recordset("Prenom")%></td>
         <td><%=obj_Recordset("Age")%></td>
         <td><%=obj_Recordset("Qualite")%></td>
         <td><%=obj_Recordset("eMail")%></td>
         <td><%=obj_Recordset("Adresse")%></td>
       </tr>
 <%
       obj_Recordset.MoveNext
       Loop
       End If
     obj_Recordset.Close
     Set obj_Recordset = Nothing
 %>
     </tr>
 </table>
 </body>
</html>

L'objet ADO Fields représente une colonne d'enregistrement possèdant un type commun de données, à l'intérieur d'un jeu d'enregistrement.

Objet_Field.Collection | Propriété | Méthode

L'utilisation de la propriété Value de l'objet Field permet de fixer ou de retourner les données pour l'enregistrement courant.

Objet_Field.Value = Valeur
Valeur = Objet_Field.Value

Les objets Field sont accessibles à partir d'une collection Fields. Ainsi, une boucle For Each...Next permet d'extraire chaque objet Field puis d'appliquer un traitement particulier au champ.

For Each Objet_Field in Objet_Recordset.Fields
 'Traitement à appliquer à Objet_Field...

<html>
 <body>
 <%
     Dim Obj_Recordset, Objet_Field
     Set Obj_Recordset = Server.CreateObject("ADODB.Recordset")
     obj_Recordset.Open "Select * from Fiche","DSN=personnel"
     With Obj_Recordset
       Compteur = .Fields.Count - 1
 %>
 <table border="1" cellpadding="3" align="center">
     <tr>
       <th>Nom</th>
       <th>Valeur</th>
       <th>Taille actuelle</th>
       <th>Taille définie</th>
       <th>Type</th>
     </tr>
       <th> </th>
       <th>Echelle num</th>
       <th>Précision</th>
       <th>Attribut</th>
       <th>Statut</th>
     </tr>
     <%
       Dim i
       Do While Not .EOF
         For i = 0 To Compteur
           For Each Objet_Field In .Fields
             Response.Write "<tr><th><i>" & Objet_Field.Name & "</i></th>"
             Response.Write "<td>" & Objet_Field.Value & "</td>"
             Response.Write "<td>" & Objet_Field.ActualSize & "</td>"
             Response.Write "<td>" & Objet_Field.DefinedSize & "</td>"
             Response.Write "<td>" & Objet_Field.Type & "</td></tr>"
             Response.Write "<tr><td> </td>"
             Response.Write "<td>" & Objet_Field.NumericScale & "</td>"
             Response.Write "<td>" & Objet_Field.Precision & "</td>"
             Response.Write "<td>" & Objet_Field.Attributes & "</td>"
             Response.Write "<td>" & Objet_Field.Status & "</td></tr>"
           Next
         Next
         .MoveNext
       Loop
       .Close
       End With
       Set obj_Recordset = Nothing
     %>
   </tr>
 </table>
 </body>
</html>

L'objet ADO Parameter représente un paramètre ou un argument associé à un objet Command dans une requête paramètrée ou une procédure stockée.

Set obj_Parameter = Server.CreateObject("ADODB.Parameter")

Suite à leur instanciation par la formule ci-dessus, les paramètres peuvent accueillir leurs différentes caractéristiques comme leur nom, leur taille, leur type et en particulier leur valeur.

Il est également possible de créer un objet Parameter directement en utilisant la méthode CreateParameter de l'objet Command. Dans ce cas, les arguments de la méthode permettent d'obtenir directement les caractéristiques du paramètre.

Set Objet_Parameter = _
Object_Command.CreateParameter(Nom, Type, _
                         ParameterDirectionEnum, Taille, Valeur)

La plupart des fournisseurs supportent les commandes paramétrées. Ces commandes stockent des instructions SQL prédéfinies accessibles à partir des requêtes de la base de données. Ces requêtes paramétrées ou ces procédures stockées comprennent dans leur code différentes variables, dont les valeurs sont récupérées par la propriété Value de l'objet Parameter sur une page Web.

CREATE PROCEDURE Nom_Procedure
  @variable varchar(50)
  @variable2 INT
AS 
SELECT T1.champ,..., T2.champN
FROM Table AS T1 INNER JOIN Table2 AS T2
ON T1.Champ = T2.Champ
WHERE T1.ChampX = @variable
AND T2.ChampX = @variable2
GO

<html>
  <body>
  <%
      Function Verif_coll_Errors(oConn)
      Dim obj_Error
      If Err.Number <> oConn.Errors(0).Number Then
        Exit Function
      End If
      If oConn.Errors.Count > 0 Then
        For Each obj_Error in obj_Connection.Errors
        If obj_Error.Number <> 0 Then
          Response.Write "" & _
            "<table border="0" cellpadding=1 cellspacing=2 border=1>" & _
            "<tr><th>Propriété</th><th>Valeur</th>" & _
            "</tr><tr><th>Numéro</th><td>" & obj_Error.Number & "</td></tr>" & _
            "<tr><th>Erreur native</th><td>" & obj_Error.NativeError & "</td></tr>" & _
            "<tr><th>Etat SQL</th><td>" & obj_Error.SQLState & "</td></tr>" & _
            "<tr><th>Source</th><td>" & obj_Error.Source & "</td></tr>" & _
            "<tr><th>Description</th><td>" & obj_Error.Description & "</td></tr>" & _
            "</table>"
          Verif_coll_Errors = True
        End If
        Next
      Else
        Verif_coll_Errors = False
      End If
      End Function

      On Error Resume Next

      Dim adCmdStoredProc
      Dim adInteger
      Dim adVarChar
      Dim adParamInput
      adCmdStoredProc = 4
      adInteger = 3
      adVarChar = 200
      adParamInput = 1

      Set obj_Connection = Server.CreateObject("ADODB.Connection")
      obj_Connection.Open "dsn=librairie"

      Set obj_Command = Server.CreateObject("ADODB.Command")
      Set obj_Parameter = Server.CreateObject("ADODB.Parameter")
      Set obj_Recordset = Server.CreateObject("ADODB.Recordset")

      Set obj_Command.ActiveConnection = obj_Connection
      obj_Command.CommandText = "choixlivre"
      obj_Command.CommandType = adCmdStoredProc

      obj_Parameter.Name = "Editeur"
      obj_Parameter.Type = adVarChar
      obj_Parameter.Direction = adParamInput
      obj_Parameter.Size = 255
      obj_Parameter.Value = "EYROLLES"
      obj_Command.Parameters.Append obj_Parameter

      Set obj_Parameter = _
        obj_Command.CreateParameter("Categorie",adInteger,adParamInput,,2)
      obj_Command.Parameters.Append obj_Parameter

      Set obj_Recordset = obj_Command.Execute

      If Verif_coll_Errors(obj_Connection) = False Then
        Compteur = obj_Recordset.Fields.Count - 1
  %>
  <table border="1" cellspacing="1" cellpadding="2">
      <tr>
        <th colspan="5">Sélection de la cétégorie n°
        <%=obj_Command.Parameters.Item("Categorie").Value%>
          et de l'éditeur 
        <%=obj_Command.Parameters.Item("Editeur").Value%>
        </th>
      </tr>
      <tr>
       <th>Livre</th>
       <th>Collection</th>
       <th>Editeur</th>
       <th>Catégorie</th>
       <th>Prix</th>
      </tr>
  <%
        Do While Not obj_Recordset.EOF
  %>
        <tr>
        <%
          For i = 0 To Compteur
        %>
            <td><%=obj_Recordset.Fields.Item(i)%></td>
        <%
          Next
        %>
        </tr>
  <%
        obj_Recordset.MoveNext
        Loop
      End If

      obj_Recordset.Close
      Set obj_Recordset = Nothing
      Set obj_Parameter = Nothing
      Set obj_Command = Nothing
      obj_Connection.Close
      Set obj_Connection = Nothing
  %>
  </table>
  </body>
</html>
<!-- Requête paramétrée dans les requêtes de la base de données : choixlivre -->
PARAMETERS NomEditeur Text ( 255 ), CodeCategorie Long;
SELECT l.nom, l.collection, l.Editeur, c.nom, l.euros
FROM livre AS l INNER JOIN categorie AS c ON l.clecategorie=c.numcategorie
WHERE (((l.editeur)=[NomEditeur]) AND ((c.numcategorie)=[CodeCategorie]))
ORDER BY l.nom;

L'objet ADO Property représente une caracéristique dynamique d'un objet ADO qui est défini par un fournisseur.

Un objet ADO possède deux types de propriétés, en l'occurrence programmé et dynamique.

Les premières sont celles exécutées dans ADO et sont immédiatement disponible à partir de n'importe quel objet nouvellement créé, en utilisant la syntaxe ci-dessous.

Objet.Property

Les propriétés programmées n'apparaissent pas comme des objets Property dans un collection Properties. Bien qu'il soit possible de modifier leur valeur, en revanche la modification de leurs caractéristiques est impossible.

Objet.Property = Valeur

Les secondes sont définies par le fournisseur de données sous-jacent, et apparaissent dans la collection ¨Properties pour l'objet ADO approprié. Les propriétés additionnelles se présentent comme des objets Property de la collection Properties de l'objet Recordset.

Les propriétés dynamiques sont disponibles à partir de l'une ou l'autre des expressions suivantes :

Objet.Properties(Index)
Objet.Properties("Nom")

<html>
  <body>
  <%
      Dim obj_Connection
      Dim obj_Recordset
      Dim ch_Source
      Dim ch_SQL

      set obj_Connection=server.CreateObject("ADODB.connection")
      ch_Source = "Provider=Microsoft.Jet.OLEDB.4.0"
      ch_Source = ch_Source & "; Data Source=C:\Base_donnee\Personnel.mdb"
      obj_Connection.connectionstring = ch_Source
      obj_Connection.Open

      set obj_Recordset = server.CreateObject("ADODB.recordset")
      ch_SQL = "SELECT Nom, Prenom FROM Fiche;"
      obj_Recordset.Open ch_SQL,obj_Connection
      Response.Write "<h3>Personnels :</h3>"
      Do until obj_Recordset.EOF
        Response.Write "<b>" & obj_Recordset("Nom") & "</b> " _
                    & obj_Recordset("Prenom") & "<br>"
        obj_Recordset.MoveNext
      Loop

      Response.Write "<h3>Propriétés de l'objet Connection :</h3>" _
      & "<table border=1>" _
      & "<tr><th>N°</th>" _
      & "<th>Type</th>" _
      & "<th>Attribut</th>" _
      & "<th>Nom</th>" _
      & "<th>Valeur</th></tr>"
      dim i
      i = 0
      for each obj_Property in obj_Connection.Properties
        i = i + 1
        Response.Write "<tr><td>" & i & "</td>"
        Response.Write "<td>" & obj_Property.type  & "</td>"
        Response.Write "<td>" & obj_Property.attributes & "</td>"
        Response.Write "<td>" & obj_Property.name  & "</td>"
        Response.Write "<td>" & obj_Property.value  & "</td></tr>"
      Next
      Response.Write "</table>"
  %>
  </body>
</html>

L'objet ADO Record représente un enregistrement dans une base de données, un fichier ou un répertoire dans un système de fichiers.

Set Objet_Record = Server.CreateObject("ADODB.Record")

ActiveX Data Objects permet de gérer des enregistrements provenant aussi bien des données structurées, telles que ceux des bases de données, que des données semi-structurées organisées en arborescence et possédant des noeuds à plusieurs niveaux comme dans la cas d'un système de fichiers.

L'objet Record, dans cette dernière situation correspond à un noeud unique de l'arborescence, comme un fichier ou un répertoire.

Si le noeud contient d'autres répertoires ou fichiers, alors cette collection de noeuds enfants correspond à un jeu d'enregistrements, autrement dit à un objet Recordset.

Set Obj_Recordset = Objet_Record.GetChildren

D'autre-part, les propriétés d'un noeud enfant sont assimilés à une collection de champs, soit à une collection Fields.

<html>
  <body>
  <%
      Dim Objet_Record, Champ
      Set Objet_Record= Server.CreateObject("ADODB.Record")

      Objet_Record.Open "", "URL=http://localhost/repertoire"

      Response.Write "<table border=1>"
      For each Champ in Objet_Record.Fields
         Response.Write "<tr><td>" & Champ.Name & _
                        "</td><td>" & Champ.Value & _
                        "</td></tr>"
      Next
      Response.Write "</table>"

      Objet_Record.Close
      Set Objet_Record = Nothing
  %>
  </body>
</html>

L'objet ADO Recordset contient l'ensemble des enregistrements d'une base de données ou le résultat d'une requête suite à l'exécution d'une commande.

Set obj_Recordset = Server.CreateObject("ADODB.Recordset")

Couramment utilisé, l'objet Recordset permet d'accomplir différentes tâches sur un jeu d'enregistrements, comme l'ouverture ou la fermeture de l'objet, mais surtout, l'extraction, l'ajout, la suppression ou la mise à jour des données.

Dim Obj_Recordset
' Instanciation de l'objet
Set Obj_Recordset = Server.CreateObject("ADODB.Recordset")
' Ouverture
Obj_Recordset.Open "SELECT * FROM Table", _
                  Obj_Connection, _
                  adOpenKeySet, _
                  adLockOptimistic

Obj_Recordset.Fields("Nom_Champs") = "Valeur du champs"
Obj_Recordset.Update ' Mise à jour
Obj_Recordset.Close ' Fermeture

Quelques unes des fonctions importantes de l'objet Recordset sont, également, d'explorer un jeu d'enregistrements par l'intermédiaire des méthodes MoveNext, MovePrevious, MoveLast, MoveFirst, Move, d'effectuer des recherches par Seek ou Find, ou de tester la position du pointeur d'enregistrement avec les propriétés BOF (Before Of File), EOF (End Of File) ou AbsolutePosition.

Do While Not Obj_Recordset.EOF ' Atteindre Fin de Fichier
  Response.Write Obj_Recordset.Fields("Nom_Champs")
  Obj_Recordset.MoveNext ' Enregistrement suivant
Loop

<html>
  <body>
  <%
      Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
      obj_Recordset.Open "Select * from Fiche","DSN=personnel"
  %>
  <table border="1" cellpadding="3" align="center">
      <tr>
        <td colspan="6">Fiches signalétiques des personnels</td>
      </tr>
      <tr>
        <td>Nom</td>
        <td>Prénom</td>
        <td>Age</td>
        <td>Qualité</td>
        <td>eMail</td>
        <td>Adresse</td>
      </tr>
        <%
        Do While Not obj_Recordset.EOF
        %>
        <tr>
          <td><%=obj_Recordset("Nom")%></td>
          <td><%=obj_Recordset("Prenom")%></td>
          <td><%=obj_Recordset("Age")%></td>
          <td><%=obj_Recordset("Qualite")%></td>
          <td><%=obj_Recordset("eMail")%></td>
          <td><%=obj_Recordset("Adresse")%></td>
        </tr>
        <%
          obj_Recordset.MoveNext
        Loop
        obj_Recordset.Close
        Set obj_Recordset = Nothing
        %>
      </tr>
  </table>
  </body>
</html>

L'objet Stream fournit les moyens de lire, écrire et gérer un flux d'octets. Ce dernier peut être composé de données textuelles ou binaires et n'est limité que dans la taille par les ressources du système.

Objet_Stream.Propriété | Méthode

Un objet Stream est utilisé pour contenir :

• les données d'un objet Recordset sauvegardé dans le format XML (eXtensible Markup Language),
• du texte ou des données binaires compris dans un fichier ou un message,
• une commande fournie par la propriété CommandStreams de l'objet Command destinée à être exécutée comme une alternative à la propriété Commandtext.

Un objet Stream peut également recevoir des résultats provenant d'un fournisseur OLE DB, autre qu'un objet Recordset, comme du XML par exemple.

Dans des sources de données semi-structurées comme un système de fichiers ou de courriers électroniques, un enregistrement peut avoir un flux de fichier binaire par défaut associées au contenu d'un fichier ou d'un courrier électronique.

Un objet Stream peut être utilisé pour manipuler des champs ou des enregistrements contenant ces flux de données.

Un objet Stream peut être obtenu à partir d'une adresse URL pointant vers un objet qui contient des données binaires ou textuelles. Cet objet peut être un document simple, un objet Record représentant un fichier ou un répertoire.

Un objet Stream par défaut peut être ouvert depuis un objet Record ou Recordset. Il est possible d'obtenir le flux par défaut associé à un enregistrement lorsque l'objet afférent est ouvert, pour éliminer un aller-retour pour l'ouverture du flux.

Les objets Stream, obtenu par instanciation, peuvent être utilisés pour stocker des données au bénéfice d'une application. Différent d'un flux associé à une adresse URL ou du flux par défaut d'un enregistrement, un objet Stream instancié ne possède aucune association avec une source sous-jacente par défaut.

Set Objet_Stream = Server.CreateObject("ADODB.Stream")

<html>
  <body>
  <%
      Dim objet_Stream
      Dim Select_Fichier
      Dim adTypeText
      adTypeText = 2
      Select_Fichier = "c:\autoexec.bat"

      set objet_Stream = Server.CreateObject("ADODB.Stream")
      objet_Stream.Open
      objet_Stream.LoadFromFile Select_Fichier
      objet_Stream.Type = adTypeText
      Objet_Stream.Charset = "ISO-8859-1"

      Taille_Fichier = objet_Stream.Size
      Affiche_Contenu= objet_Stream.ReadText

      Response.Write "Fichier : " & Select_Fichier & "<br>"
      Response.Write "Taille : " & Taille_Fichier & " Octets<br>"
      Response.Write "Contenu : " & Affiche_Contenu

      objet_Stream.Close
      set objet_Stream = nothing
  %>
  </body>
</html>

Les collections ADO contiennent chacune d'aucun à plusieurs objets du même type.

Toutes ses collections possèdent des propriétés identiques, en l'occurrence Count comptabilisant le nombre d'éléments, et Item indiquant un membre spécifique par un index ou son nom.

Il est possible de parcourir les objets d'une collection par l'intermédiaire d'un instruction de boucles For Each...Next.

For Each Objet In Collection
  ' Instructions...
Next

La collection ADO Errors contient tous les objets Error créés en réponse à un seul échec relatif au fournisseur.

Objet_Connection.Errors.Propriété | Méthode

Seul l'objet Connection permet d'accéder à la collection Errors. Bien que paraissant restrictif, il n'est pas obligatoire de faire appel à un objet Connection explicite puisque la propriété ActiveConnection des objets Command, Record ou Recordset autorise l'accès à la collection Errors.

Objet.ActiveConnection.Errors

Lorsqu'une seconde erreur relative à un autre objet ADO intervient, la collection Errors est réinitialisée et à nouveau remplie par les caractéristiques de la nouvelle erreur.

Le fournisseur OLE DB peut également insérer des informations ou des avertissements à l'index zéro de la collection Errors.

<html>
  <head>
  <%
      Function Verif_coll_Errors(obj_Connection)
      Dim obj_Error
      If Err.Number <> obj_Connection.Errors(0).Number Then
        Exit Function
      End If
      If obj_Connection.Errors.Count > 0 Then
        For Each obj_Error in obj_Connection.Errors
        If obj_Error.Number <> 0 Then
          Response.Write "" & _
            "<table border="0" cellpadding=1 cellspacing=2 border=1>" & _
            "<tr><th>Propriété</th><th>Valeur</th>" & _
            "</tr><tr><th>Numéro</th><td>" & obj_Error.Number & "</td></tr>" & _
            "<tr><th>Erreur native</th><td>" & obj_Error.NativeError & "</td></tr>" & _
            "<tr><th>Etat SQL</th><td>" & obj_Error.SQLState & "</td></tr>" & _
            "<tr><th>Source</th><td>" & obj_Error.Source & "</td></tr>" & _
            "<tr><th>Description</th><td>" & obj_Error.Description & "</td></tr>" & _
            "</table>"
          Verif_coll_Errors = True
        End If
        Next
      Else
        Verif_coll_Errors = False
      End If
      End Function

      On Error Resume Next
  %>
  </head>
  <body>
  <%
      Dim Ch_SQL
      Ch_SQL = "SELECT Noms, Prenom, Age, Qualites, eMail, Adresse" _
             & "FROM Fiche","DSN=personnel"
      Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
      obj_Recordset.Open Ch_SQL
        If Verif_coll_Errors(obj_Recordset.ActiveConnection) = False Then
  %>
        <table border="1" cellpadding="3" align="center">
        <tr>
          <td colspan="6">Fiches signalétiques des personnels</td>
        </tr>
        <tr>
          <td>Nom</td>
          <td>Prénom</td>
          <td>Age</td>
          <td>Qualité</td>
          <td>eMail</td>
          <td>Adresse</td>
        </tr>
  <%
        Do While Not obj_Recordset.EOF
  %>
        <tr>
          <td><%=obj_Recordset("Nom")%></td>
          <td><%=obj_Recordset("Prenom")%></td>
          <td><%=obj_Recordset("Age")%></td>
          <td><%=obj_Recordset("Qualite")%></td>
          <td><%=obj_Recordset("eMail")%></td>
          <td><%=obj_Recordset("Adresse")%></td>
        </tr>
  <%
        obj_Recordset.MoveNext
        Loop
        End If
      obj_Recordset.Close
      Set obj_Recordset = Nothing
  %>
      </tr>
  </table>
  </body>
</html>

La collection ADO Fields contient tous les objets Field correspondant chacun à une colonne d'un jeu d'enregistrements (Recordset) ou d'un seul enregistrement (Record).

Set objet_Fields = objet_Recordset.Fields

L'extraction des valeurs de champs peut s'effectuer de différentes façons. Cependant, si la position des champs est connue dans la table de données, l'accès par un index reste la méthode la plus performante.

objet_Field = obj_Recordset.Fields.Item("Nom_Champ")
objet_Field = obj_Recordset.Fields("Nom_Champ")
objet_Field = obj_Recordset("Nom_Champ")
objet_Field = obj_Recordset.Fields.Item(Index)
objet_Field = obj_Recordset.Fields(Index)
objet_Field = obj_Recordset(Index)

Dans le cas de données structurées comme des bases de données SQL, la colletion Fields contient des enregistrements (objets Field) correspondant à des colonnes de données et contiennent des informations relatives aux colonnes telles que leur type de données, leur taille, leur nom, etc..

Dans le cas de données semi-structurées comme un système de fichiers, la collection Fields correspond à l'ensemble des propriétés de l'objet. Ainsi, chaque propriété à l'image ddu nom, de la taille, des attributs etc. constitue un enregistrement spécifique dans la collection.

<html>
  <body>
  <%
      Set obj_Recordset = Server.CreateObject("ADODB.Recordset")
      obj_Recordset.Open "Select * from Fiche","DSN=personnel"
      With Obj_Recordset
        Compteur = .Fields.Count - 1
  %>
  <table border="1" cellpadding="3" align="center">
      <tr>
        <td colspan="7">Fiches signalétiques des personnels</td>
      </tr>
      <tr>
        <td>N°</td>
        <td>Nom</td>
        <td>Prénom</td>
        <td>Age</td>
        <td>Qualité</td>
        <td>eMail</td>
        <td>Adresse</td>
      </tr>
        <%
        Dim i
        Do While Not .EOF
        %>
        <tr>
        <%
          For i = 0 To Compteur
        %>
            <td><%=.Fields.Item(i)%></td>
        <%
          Next
        %>
        </tr>
        <%
            .MoveNext
          Loop
          .Close
        End With
        Set obj_Recordset = Nothing
        %>
      </tr>
  </table>
  </body>
</html>

La collection ADO Parameters contient tous les objets Parameter d'un objet Command.

Parameters.Propriété | Méthode

Les paramètres sont généralement utilisées avec des procédures stockées dans des bases de données SQL et dans ce cas fonctionnent comme des arguments transmettant leur valeur à une fonction ou une procédure SQL.

La création des paramètres passe par l'objet Command associé à sa méthode CreateParameter.

Set Objet_Parameter = _
  Objet.Command.CreateParameter(Nom, Type, Direction, Taille, Valeur)

Ensuite, il ne reste plus qu'à insérer les paramètres ainsi créés dans le collection Parameters par l'intermédiaire de sa méthode Append.

Objet_Command.Parameters.Append Objet_parameter

L'accès à la valeur d'un paramètre précis peut s'effectuer soit par son nom ou son index à partir de la collection.

Valeur = Object_Command.Parameters(Index)
Valeur = Object_Command.Parameters("Nom")

Enfin, il est également possible de modifier la valeur d'un paramètre de la même façon.

Object_Command.Parameters(Index) = Valeur
Object_Command.Parameters("Nom") = Valeur

L'index de la collection Parameter commençant par la valeur zéro, le premier paramètre est accessible à partir de zéro.

<html>
  <body>
  <%
      Function Verif_coll_Errors(oConn)
      Dim obj_Error
      If Err.Number <> oConn.Errors(0).Number Then
        Exit Function
      End If
      If oConn.Errors.Count > 0 Then
        For Each obj_Error in obj_Connection.Errors
        If obj_Error.Number <> 0 Then
          Response.Write "" & _
            "<table border="0" cellpadding=1 cellspacing=2 border=1>" & _
            "<tr><th>Propriété</th><th>Valeur</th>" & _
            "</tr><tr><th>Numéro</th><td>" & obj_Error.Number & "</td></tr>" & _
            "<tr><th>Erreur native</th><td>" & obj_Error.NativeError & "</td></tr>" & _
            "<tr><th>Etat SQL</th><td>" & obj_Error.SQLState & "</td></tr>" & _
            "<tr><th>Source</th><td>" & obj_Error.Source & "</td></tr>" & _
            "<tr><th>Description</th><td>" & obj_Error.Description & "</td></tr>" & _
            "</table>"
          Verif_coll_Errors = True
        End If
        Next
      Else
        Verif_coll_Errors = False
      End If
      End Function

      On Error Resume Next

      Dim adCmdStoredProc
      Dim adInteger
      Dim adVarChar
      Dim adParamInput
      adCmdStoredProc = 4
      adInteger = 3
      adVarChar = 200
      adParamInput = 1

      Set obj_Connection = Server.CreateObject("ADODB.Connection")
      obj_Connection.Open "dsn=librairie"

      Set obj_Command = Server.CreateObject("ADODB.Command")
      Set obj_Parameter = Server.CreateObject("ADODB.Parameter")
      Set obj_Recordset = Server.CreateObject("ADODB.Recordset")

      Set obj_Command.ActiveConnection = obj_Connection
      obj_Command.CommandText = "choixlivre"
      obj_Command.CommandType = adCmdStoredProc

      obj_Parameter.Name = "Editeur"
      obj_Parameter.Type = adVarChar
      obj_Parameter.Direction = adParamInput
      obj_Parameter.Size = 255
      obj_Parameter.Value = "EYROLLES"
      obj_Command.Parameters.Append obj_Parameter

      Set obj_Parameter = _
        obj_Command.CreateParameter("Categorie",adInteger,adParamInput,,2)
      obj_Command.Parameters.Append obj_Parameter

      Set obj_Recordset = obj_Command.Execute

      If Verif_coll_Errors(obj_Connection) = False Then
        Compteur = obj_Recordset.Fields.Count - 1
  %>
  <table border="1" cellspacing="1" cellpadding="2">
      <tr>
        <th colspan="5">Sélection de la cétégorie n°
        <%=obj_Command.Parameters.Item("Categorie").Value%>
          et de l'éditeur 
        <%=obj_Command.Parameters.Item("Editeur").Value%>
        </th>
      </tr>
      <tr>
       <th>Livre</th>
       <th>Collection</th>
       <th>Editeur</th>
       <th>Catégorie</th>
       <th>Prix</th>
      </tr>
  <%
        Do While Not obj_Recordset.EOF
  %>
        <tr>
        <%
          For i = 0 To Compteur
        %>
            <td><%=obj_Recordset.Fields.Item(i)%></td>
        <%
          Next
        %>
        </tr>
  <%
        obj_Recordset.MoveNext
        Loop
      End If

      obj_Recordset.Close
      Set obj_Recordset = Nothing
      Set obj_Parameter = Nothing
      Set obj_Command = Nothing
      obj_Connection.Close
      Set obj_Connection = Nothing
  %>
  </table>
  </body>
</html>
<!-- Requête paramétrée dans les requêtes de la base de données : choixlivre -->
PARAMETERS NomEditeur Text ( 255 ), CodeCategorie Long;
SELECT l.nom, l.collection, l.Editeur, c.nom, l.euros
FROM livre AS l INNER JOIN categorie AS c ON l.clecategorie=c.numcategorie
WHERE (((l.editeur)=[NomEditeur]) AND ((c.numcategorie)=[CodeCategorie]))
ORDER BY l.nom;

La collection ADO Properties contient tous les objets Property d'une instance d'objet.

Properties.Propriété | Méthode

Les objets ADO, Connection, Command, Recordset, Record, et Field possèdent une collection Properties constituée d'objets Property,. Chacun de ces-derniers correspond à une caractéristique de l'objet ADO, spécifique au fournisseur.

ADO fonctionnant avec différents types de sources de données, la collection Properties devient dynamique, puisque chacun de ses objets Property sont susceptibles de varier selon le fournisseur OLE DB sollicité.

Les propriétés dynamiques sont disponibles à partir de l'une ou l'autre des expressions suivantes :

Objet.Properties(Index)
Objet.Properties("Nom")

<html>
  <body>
  <%
      Dim obj_Connection
      Dim obj_Recordset
      Dim ch_Source
      Dim ch_SQL

      set obj_Connection=server.CreateObject("ADODB.connection")
      ch_Source = "Provider=Microsoft.Jet.OLEDB.4.0"
      ch_Source = ch_Source & "; Data Source=C:\Base_donnee\Personnel.mdb"
      obj_Connection.connectionstring = ch_Source
      obj_Connection.Open

      set obj_Recordset = server.CreateObject("ADODB.recordset")
      ch_SQL = "SELECT Nom, Prenom FROM Fiche;"
      obj_Recordset.Open ch_SQL,obj_Connection
      Response.Write "<h3>Personnels :</h3>"
      Do until obj_Recordset.EOF
        Response.Write "<b>" & obj_Recordset("Nom") & "</b> " _
                    & obj_Recordset("Prenom") & "<br>"
        obj_Recordset.MoveNext
      Loop

      Response.Write "<h3>Propriétés de l'objet Connection :</h3>" _
      & "<table border=1>" _
      & "<tr><th>N°</th>" _
      & "<th>Type</th>" _
      & "<th>Attribut</th>" _
      & "<th>Nom</th>" _
      & "<th>Valeur</th></tr>"
      dim i
      i = 0
      for each obj_Property in obj_Connection.Properties
        i = i + 1
        Response.Write "<tr><td>" & i & "</td>"
        Response.Write "<td>" & obj_Property.type  & "</td>"
        Response.Write "<td>" & obj_Property.attributes & "</td>"
        Response.Write "<td>" & obj_Property.name  & "</td>"
        Response.Write "<td>" & obj_Property.value  & "</td></tr>"
      Next
      Response.Write "</table>"
  %>
  </body>
</html>

Un curseur représente un moyen de déplacer un pointeur, d'un enregistrement à un autre dans un objet Recordset.

ADO définit quatre types de curseurs, dont les principales différences résident d'une part, dans le mode de déplacement aussi bien en avant qu'en arrière, et d'autre part dans la visibilité ou l'occultation des jeux d'enregistrements sur lesquels des actions ont été opérés, pour les autres utilisateurs.

Il faut choisir le type de curseur par l'intermédiaire de la propriété CursorType avant l'ouverture de l'objet Recordset, ou de la méthode Open en passant un argument CursorType.

Plusieurs fournisseurs ne supportent pas tous les types de curseurs. Par défaut, ADO utilise le type de curseur forward-only en principe reconnu par tous.

Les constantes permettent de définir différentes caractéristiques prédéfinies pour les méthodes et propriétés des objets ADO.

Les constantes AffectEnum indique quels enregistrements sont affectés par une opération.

Objet_Recordset.CancelBatch AffectEnum

Les constantes BookmarkEnum spécifient un signet indiquant où l'opération doit débuter.

Objet_Recordset.Move Nb_Enregistrements, BookmarkEnum

Les constantes CommandTypeEnum sont des valeurs représentant comment un argument pourrait être interprété.

Object_Command.CommandType = CommandTypeEnum

Les constantes CompareEnum indique la position relative de deux enregistrements par leur signet.

Objet_Recordset.CompareBookmarks Signet, Signet2 = _
                                                                        CompareEnum

Les constantes ConnectModeEnum indique les permissions disponibles pour la modification des données dans un objet Connection, pour l'ouverture d'un enregistrement Record, ou pour la spécification des valeurs pour la propriété Mode des objets Record et Stream.

Objet_Connection.Mode = ConnectModeEnum

Les constante CopyRecordOptionsEnum indiquent le comportement de la méthode CopyRecord.

Objet_Record.CopyRecord CopyRecordOptionsEnum

Les constantes CursorLocationEnum permettent de spécifier la localisation du service de curseur.

Objet_Connection.CursorLocation = CursorLocationEnum

Les constantes CursorOptionEnum spécifient quelle fonctionnalité, la méthode Supports doit évaluer.

Objet_Recordset.Supports(CursorOptionEnum)

Les constantes EditModeEnum spécifient les positions d'édition d'un enregistrement.

Objet_Recordset.EditMode = EditModeEnum

Les constantes DataTypeEnum spécifient le type de données des objets Field, Parameter ou Property.

Objet_Field.Type = DataTypeEnum

Les constantes EditModeEnum spécifient les positions d'édition d'un enregistrement.

Objet_Recordset.EditMode = EditModeEnum

Les constantes EventReasonEnum spécifient la raison qui a amené un événement à se produire.

Objet_Recordset.RecordChangeComplete EventReasonEnum, 
                         Nb_Records, Erreur, EventStatusEnum, Recordset

Les constantes EventStatusEnum spécifient le statut courant de l'exécution d'un événement.

Objet_Recordset.EndOfRecordset More Data, _
                                                   EventStatusEnum, Recordset

Les constantes ExecuteOptionEnum spécifie comment un fournisseur devrait exécuter une commande.

Objet_Recordset.Open Source, ActiveConnection, _
                  CursorTypeEnum, LockTypeEnum, ExecuteOptionEnum

Les constantes FieldAttributeEnum spécifient un ou plusieurs attributs d'un objet Field.

Fields.Append Nom_Field, Type, Taille_Champs, _
                        FieldAttributeEnum, Valeur

Les constantes FieldStatusEnum indiquent le statut d'un objet Fields.

FieldStatusEnum = Objet.Status

Les constantes FilterGroupEnum indique les groupes d'enregistrements devant être filtré à partir d'un objet Recordset.

Objet_Recordset.Filter = FilterGroupEnum

La constante GetRowsOptionEnum spécifie combien d'enregistrements à retrouver à partir d'un objet Recordset.

Objet_Recordset.GetRows(GetRowsOptionEnum, _
                               BookmarkEnum, Enregistrements)

Les constantes IsolationLevelEnum indique le niveau d'isolation de transaction pour un objet Connection.

Objet_Connection.IsolationLevel = IsolationLevelEnum

Les constantes LineSeparatorsEnum indiquent le caractère à utiliser comme séparateur de ligne dans le texte d'un objet Stream.

Objet_Stream.LineSeparator = LineSeparatorsEnum

Les constantes LockTypeEnum indique le type de verrou placé sur les enregistrements durant l'opération d'édition.

Objet_Recordset.LockType = LockTypeEnum

Les constantes MarshalOptionsEnum indique quels enregistrements devraient être retournés au serveur.

Objet_Recordset.MarshalOptions = MarshalOptionsEnum

Les constantes MoveRecordOptionsEnum indiquent le comportement de la méthode MoveRecord de l'objet Record.

Objet_Record.MoveRecord(Source, Destination, _
                       Nom_Utilisateur, Mot_Passe, _
                       MoveRecordOptionsEnum, Bool_Asynchrone)

Les constantes ObjectStateEnum représente l'état d'un objet, c'est-à-dire s'il est ouvert ou fermé, connecté à la source de donées, en exécution d'une commande ou en recherche de données.

Object_Command.State = ObjectStateEnum

Les constantes ParameterDirectionEnum indiquent si l'objet Parameter représente un paramètre entrée, un paramètre produit, les deux, ou la valeur retournée à partir d'une procédure stockée.

FieldStatusEnum = Objet.Status

Les constantes PersistFormatEnum spécifient le format de sauvegarde d'un objet Recordset.

bjet_Recordset.Save Destination, PersistFormatEnum

Les constantes PositionEnum spécifient la position courante du pointeur d'enregistrement à l'intérieur d'un objet Recordset.

Objet_Recordset.AbsolutePage = PositionEnum

Les constantes RecordCreateOptionsEnum spécifient si un enregistrement existant doit être ouvert ou un nouvel enregistrement doit être creéé par la méthode Open de l'objet Record. Les valeurs peuvent être combinées avec l'opérateur AND.

Objet_Record.Open Source, ActiveConnection, 
                 RecordCreateOptionsEnum, RecordOpenOptionsEnum,
                 Nom_Utilisateur, Mot_Passe

Les constantes RecordOpenOptionsEnum spécifient les options pour l'ouverture d'un objet Record. Ces valeurs peuvent être combinées en utilisant l'opérateur OR.

Objet_Record.Open Source, ActiveConnection, 
                 RecordCreateOptionsEnum, RecordOpenOptionsEnum,
                 Nom_Utilisateur, Mot_Passe

Les constantes RecordStatusEnum indique le statut d'un enregistrement par rapport à des mises à jour par lot et d'autres opérations par groupe.

Objet_Recordset.Status = RecordStatusEnum

Les constantes RecordTypeEnum indiquent le type de l'objet Record.

Objet_Record.RecordType = RecordTypeEnum

Les constantes ResyncEnum indique si les valeurs sous-jacentes sont recopiées par un appel à la méthode Resync.

Objet_Recordset.Resync AffectEnum, ResyncEnum

Les constantes SaveOptionsEnum spécifient si un fichier doit être créé ou recopié lors de la sauvegarde à partir d'un objet Stream. Les valeurs peuvent être combinées avec un opérateur AND.

Objet_Stream.SaveToFile Fichier, SaveOptionsEnum

Les constantes SchemaEnum indique le type de schéma d'un jeu d'enregistrements Recordset que la méthode OpenSchema récupère.

Set Objet_Recordset = _
                      Objet_Connection.OpenSchema(SchemaEnum, _
                                                   Critères, ID_Schema)

Les constantes SearchDirectionEnum indiquent la direction d'une recherche d'enregistrement à l'intérieur d'un objet recordset

Objet_Recordset.Find(Critère, Saut_ligne, _
                        SearchDirectionEnum, Démarrage)

Les constantes SeekEnum indique le type de recherche à exécuter.

Objet_Recordset.Seek Tableau_Valeurs, SeekEnum

Les constantes de la méthode Stat, c'est-à-dire StatStg et StatFlag permettent de récupérer une information à propos de l'objet Stream.

Objet_Stream.Stat(StatStgEnum, StatFlag)

Le paramètre StatStg indique une structure STATSTG qui sera remplie avec l'information à proposde l'objet Stream. La mise en oeuvre de la méthode Stat utilisée par l'objet Stream d'ADO ne se remplit pas dans tous les champs de la structure.

Le paramètre StatFlag indique que cette méthode ne retourne aucuns des membres dans la structure de STATSTG, sauvegardant ainsi une opération d'allocation de mémoire. Les valeurs sont fixées selon les valeurs possibles de STATFLAG.

Les constantes StreamOpenOptionsEnum indiquent les options pour l'ouverture d'un objet Stream. Les valeurs peuvent être combinées par un opérateur OR.

Objet_Stream.Open Source, ConnectModeEnum, _
               StreamOpenOptionsEnum, Nom_Utilisateur, Mot_Passe

Les constantes StreamTypeEnum indiquent le type de données stockées dans un objet Stream.

Objet_Stream.Type = StreamTypeEnum

Les constantes StreamWriteEnum indiquent si un séparateur de ligne est ajouté à une chaîne de caractères écrite dans un objet Stream.

Objet_Stream.WriteText Donnée, StreamWriteEnum

La constante StringFormatEnum indique le format à utiliser pour construire la chaîne de caractères retournée suite à la récupération des enregistrements.

Objet_Recordset.GetString(StringFormatEnum)

Les commandes select et FROM sont utilsées pour sélectionner des tables dans une base de données.

Il est également possible de sélectionner de un à plusieurs champs en séparant les noms de champs ou de colonnes par une virgule. Pour sélectionner tous les champs, il suffit d'utiliser une étoile à la place des nomds de champs.

select nom_champ,..., nom_champN FROM nom_table

select Livre FROM Librairie
' retourne
ORACLE SQL : THE ESSENTIAL REFERENCE (EN ANGLAIS)
ORACLE SQL* LOADER : THE DEFINITIVE GUIDE (EN ANGLAIS)
INITIATION A SQL - COURS ET EXERCICES CORRIGES
SQL
MAITRISEZ SQL
SQL
KIT DE FORMATION MICROSOFT SQL 
        SERVER 2000 ADMINISTRATION SYSTEME

La commande DISTINCT sélectionne chaque élément distinct d'une colonne de données.

La commande ALL indique que les doublons peuvent apparaître dans le résultat d'une requête, elle constitue la commande par défaut de select.

select DISTINCT nom_champ FROM nom_table

select DISTINCT Livre FROM Librairie

' retourne
ORACLE SQL : THE ESSENTIAL REFERENCE (EN ANGLAIS)
ORACLE SQL* LOADER : THE DEFINITIVE GUIDE (EN ANGLAIS)
INITIATION A SQL - COURS ET EXERCICES CORRIGES
SQL
MAITRISEZ SQL
KIT DE FORMATION MICROSOFT SQL 
        SERVER 2000 ADMINISTRATION SYSTEME

La commande WHERE pose une condition dans la requête de sélection. L'expression conditionnelle peut être construite à l'aide de plusieurs prédicats constitués d'opérateurs de comparaisons (= | <> | != | > | > = | !> | < | <= | !<)et séparés par des opérateurs booléens AND, OR ou NOT.

select "nom_champ"
FROM "nom_table"
WHERE "condition"

select Livre FROM Librairie WHERE Prix < 200

' retourne
INITIATION A SQL - COURS ET EXERCICES CORRIGES
SQL
SQL

La commande GROUP BY spécifie des groupes dans lesquels les lignes de sortie doivent être placées et calcule une valeur de résumé pour chacun des groupes si des fonctions d'agrégation sont employées avec la commande select.

select nom_champ,
Fonction_Agregation
FROM nom_table
GROUP BY nom_champ2

select Editeur,
SUM(Prix)
FROM Librairie
GROUP BY Editeur

' retourne

  

      
O'REILLY
      
616.00
  
  

      
EYROLLES
      
183.00
  
  

      
CAMPUSPRESS FRANCE
      
62.00
  
  

      
WROX PRESS
      
286.00
  
  

      
ENI
      
140.00
  
  

      
MICROSOFT PRESS
      
284.00
  

La commande HAVING spécifie un critère de recherche pour un groupe ou une fonction d'agrégation. HAVING est génralement utilisé avec GROUP BY, sinon HAVING se comporte à l'instar de WHERE.

select nom_champ,
Fonction_Agregation
FROM nom_table
GROUP BY nom_champ2
HAVING "Condition"

select Editeur,
SUM(Prix)
FROM Librairie
GROUP BY Editeur
HAVING SUM(Prix) > 200

' retourne

  

      
O'REILLY
      
616.00
  
  

      
WROX PRESS
      
286.00
  
  

      
MICROSOFT PRESS
      
284.00
  

Les alias concourrent à améliorer la lisibilité d'une requête. Il existe deux types d'alias : les alias de tables et les alias de champs. Les alias peuvent également s'appliquer à une fonction d'agrégation retournant des données sous forme de colonnes.

select Alias_table.nom_champ Alias_champ
FROM nom_table AS Alias_table

select L.Editeur Edi,
SUM(L.Prix) F
FROM Librairie As L
GROUP BY Edi
HAVING F > 200

' retourne

  

      
O'REILLY
      
616.00
  
  

      
WROX PRESS
      
286.00
  
  

      
MICROSOFT PRESS
      
284.00
  

Les commandes de jointures de tables donnent la possibilité d'appliquer des requêtes sur plusieurs tables d'une base de données.

select tab.nom_champ
FROM nom_table As tab
[INNER | {{LEFT | RIGHT | FULL } [ OUTER]}]
         JOIN  nom_table2 As tab2
ON Condition

La condition de la commande ON permet de comparer les tables jointes par l'intermédiaire de champs dont les valeurs sont identiques et comparables.

INNER JOIN (option par défaut) indique toutes les paires correspondantes des lignes renvoyées et supprime les lignes n'ayant pas de correspondance entre les deux tables.

FULL OUTER JOIN indique qu'une ligne de la table de gauche ou de droite, ne respectant pas la condition de jointure, est comprise dans le jeu de résultats et que les colonnes de sortie correspondant à l'autre table comportent des valeurs NULL.

LEFT OUTER JOIN indique que toutes les lignes de la table de gauche ne respectant pas la condition de jointure sont incluses dans le jeu de résultats, et que les colonnes de sortie de l'autre table ont des valeurs NULL en plus de toutes les lignes renvoyées par la jointure interne.

RIGHT OUTER JOIN indique que toutes les lignes de la table de droite ne respectant pas la condition de jointure sont comprises dans le jeu de résultats, et que les colonnes de sortie correspondant à l'autre table ont des valeurs NULL en plus de toutes les lignes renvoyées par la jointure interne.

select  L.ISBN, L.Editeur, E.Adresse
FROM Librairie As L
INNER JOIN Edition As E
ON L.Editeur = E.Editeur

select  L.ISBN, L.Editeur, E.Adresse
FROM Librairie As L
LEFT OUTER JOIN Edition As E
ON L.Editeur = E.Editeur

Les fonctions d'agrégation accomplissent un calcul sur plusieurs valeurs et retournent un résultat et sont souvent utilisées avec les commandes GROUP BY et select.

Hormis la fonction COUNT, les fonctions d'agrégation ne tiennent pas compte des valeurs NULL.

select COUNT(Livre)
FROM Librairie

' retourne
7

SELECT SUM(Prix)
FROM Librairie

' retourne
1 571