Définition et manipulation de données avec DAO

Il existe cinq types de Recordset :

1. Recordset de type Table :

Un Recordset de type Table permet d'accéder directement au contenu d'une table. Son contenu est dynamique, ce qui signifie que les mises à jour sont directement répercutées dans le jeu d'enregistrement. La source d'un tel Recordset est le nom d'une table.

Attention ce type est incompatible avec les tables liées (provenant d'une autre base de données)

2. Recordset de type Dynaset :

Un Recordset de type Dynaset correspond au résultat d'une instruction SQL retournant des enregistrements. Son contenu est dynamique et sa source peut être soit le nom d'une table, d'une requête ou bien une instruction SQL valide.

3. Recordset de type Snapshot :

Un Recordset de type Snapshot correspond à une photographie des données à un instant donné (son ouverture). Les modifications apportées dans la base de données aprés l'ouverture d'un tel curseur ne sont pas répercutées dans le jeu d'enregistrements. Son contenu est donc statique et sa source est définit comme celle d'un Recordset de type Dynaset.

4. Recordset de type ForwardOnly :

Il s'agit d'un Recordset de type Snapshot à la différence qu'il ne permet de se déplacer exclusivement vers l'avant. Il est impossible de repartir au début du jeu d'enregistrement, ni même de reculer au cours de la lecture des données.

5. Recordset de type Dynamic :

Ce type de Recordset est semblable au type Dynaset à la différence qu'il s'applique exclusivement aux sources de données ODBC Direct.

L'objet Database (et donc indirectement CurrentDB) est muni de la méthode OpenRecordset qui instancie un nouvel objet Recordset et l'ajoute à la collection Database.Recordsets.

La syntaxe de cette méthode est la suivante :

Set recordset = Database.OpenRecordset (source, [type, options, lockedits])

source : Il s'agit de la source d'enregistrements du Recordset. Il peut s'agir du nom d'une table, d'une requête ou d'une instruction SQL valide retournant des enregistrements (SELECT). Dans le cas d'un Recordset de type Table, cet argument est restreint au nom d'une table.

Pour être valide, l'instruction SQL doit tenir compte des différents types de champ dans l'expression des critères. Ainsi, si le champ NomClient est de type texte, la variable source sélectionnant le client nommé Dupont sera :

Source="SELECT * FROM Client WHERE NomClient=" & chr(34) & "Dupont" & chr(34)

La fonction Chr(34) permet d'encadrer un critère de type texte avec des guillemets. En effet, nous n'aurions pas pu écrire :

Source="SELECT * FROM Client WHERE NomClient="Dupont""

En effet, dans ce cas, le " avant Dupont correspondrait à la fermeture de guillemet associée au premier caractère " (avant SELECT). Une erreur serait donc levé par le compilateur. Une solution possible est donc d'utiliser le code Ascii du caractère ". Le contenu de la variable utilisant la fonction Chr sera aprés concaténation :

SELECT * FROM Client WHERE NomClient="Dupont"

Toutefois, il reste encore un problème. Si dans la valeur recherchée figure un guillemet, le moteur Jet va l'interpréter lui aussi comme une fin de chaine de caractère. La solution est de doubler les guillemets dans l'expression du critère :

Source="SELECT * FROM Client WHERE NomClient=" & chr(34) & Replace(MaVariable,chr(34),chr(34) & chr(34)) & chr(34)

Ainsi, si MaVariable est égale à Monsieur "X", alors la fonction Replace retournera Monsieur ""X"". La source du Recordset sera, aprés concaténation :

SELECT * FROM Client WHERE NomClient="Monsieur ""X"""

Le type Date est plus simple à traiter, il faut encadrer la valeur du critère par des #. Notons tout de même que les dates doivent être en format américain : mm/jj/yyyy.

Un recordset sélectionnant les commandes du 10 décembre 2003 sera initialisé avec la source suivante :

Source="SELECT * FROM Commande WHERE DateCommande=#12/10/2003#"

Type : Cet argument correspond au type du recordset à générer. Les constantes disponibles sont :

Options : Ce paramètre définit les paramètres optionnels du Recordset. Il s'agit d'une (ou une combinaison) des constantes suivantes :

Certaines constantes ont été volontairement oubliées dans cette liste du fait qu'elles sont soit inapplicables sous Access, soit déconseillées.

LockEdits : Il s'agit du mode de verrouillage des données utilisé par le Recordset.
Les constantes disponibles sont :

Certaines constantes ont été volontairement oubliées dans cette liste du fait qu'elles sont inapplicables sous Access.

Exemple :

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("SELECT * FROM Client WHERE NumClient=2",dbOpenDynaset)

Cet exemple ouvre un Recordset retournant le client possédant le numéro 2.

Si vous souhaitez accéder aux données d'une requête enregistrée vous pouvez utiliser la méthode OpenRecordset de l'objet QueryDef correspondant plutôt que d'utiliser celle de l'objet Database qui nécessite de passer en paramètre le nom de la requête.

La syntaxe de cette méthode est la suivante :

Set recordset = QueryDef.OpenRecordset ([type, options, lockedits])

Les arguments à utiliser sont les mêmes que ceux de la méthode Database.OpenRecordset. Notons toutefois qu'il est impossible d'ouvrir un Recordset de type Table sur un objet QueryDef.

Dans le cas d'une requete paramétrée, vous devez affecter les paramètres avant d'ouvrir le recordset. Il est impossible d'ouvrir un recordset sur une requete qui demande à l'utisateur de saisir des critères via une boite de dialogue (type inputbox). Une erreur d'éxecution ( X arguments attendus serait alors levée).

Sans que vous le sachiez, vous avez déjà manipuler des objets Recordset par le biais d'un formulaire. En effet, tout formulaire (et état) Access possédant une source de données (Propriété Source / RecordSource) utilise un curseur pour afficher et manipuler les données qu'il contient. Vous pouvez vous même agir sur ce jeu d'enregistrement via la propriété Recordset du formulaire. Ainsi, si vous utilisez la méthode Movenext sur le Recordset du formulaire, vous vous apercevrez que votre formulaire a atteint l'enregistrement suivant. Notons aussi que tout déplacement dans le Recordset du formulaire entraine l'appel de l'evenement Form_Current (sur activation) du formulaire.

Syntaxe :

Set recordset=Me.Recordset

La méthode RecordsetClone d'un formulaire permet de dupliquer le jeu d'enregistrements du formulaire afin que vous puissiez manipuler les données sans que ces modifications ne soient répercutées sur le formulaire et sans qu'aucun évènement ne soit déclenché. Pour que le formulaire prenne en compte les modifications apportées sur le jeu d'enregistrements, il est nécessaire d'appeler la méthode Requery de ce formulaire.

Set recordset=Me.RecordsetClone

Lorsque vous manipulez les recordsets, une quantité importante de données est chagée en mémoire. Pour la libérer il est nécessaire de procéder en deux temps :

1. appel de la méthode Recordset.Close,
2. affectation de Nothing à la variable.

Si la phase Set Recordset=Nothing est optionnelle car les variables seront inévitablement détruites à la fin de la procédure (hors variables publiques détruite en fin d'application), l'appel à Close à quant à lui un caractère obligatoire. En effet, une non fermeture systématique des Recordsets est à l'origine de l'accroissement si particulier de la taille des bases de données Access, obligeant l'utilisateur à recourrir au compactage régulièrement.

Une bonne pratique consiste à placer la ligne suivante dès qu'un recordset n'est plus utile :

oRst.Close : Set oRst=Nothing

Lorsque vous initialisez un jeu d'enregistrements, l'enregistrement courant est le premier si le recordset n'est pas vide. Toutefois, il existe deux positions particulières :

• une avant le premier enregistrement. Lorsque vous êtes à cet emplacement, la propriété BOF du Recordset est égale à True
• une après le dernier enregistrement. Dans ce cas, la propriété EOF est égale à True.

Dans le cas où le jeu d'enregistrement est vide, la position courante se trouve à la fois avant le premier enregistrement et aprés le dernier. Ainsi, pour tester si le Recordset est vide ou pas, il suffit d'utiliser la condition suivante :

If Not oRecordset.EOF Then
  Msgbox "Le jeu d'enregistrements n'est pas vide"
else
  Msgbox "Le jeu d'enregistrements est vide"
End if

Cinq méthodes sont disponibles pour se déplacer dans le Recordset :

• MovePrevious permet d'atteindre l'enregistrement précédent.
• MoveNext permet d'atteindre l'enregistrement suivant.
• MoveFirst permet d'atteindre le premier enregistrement.
• MoveLast permet d'atteindre le dernier enregistrement.
• Move permet un déplacement relatif par rapport à la position courante..

Exemple :

'Se place sur le premier enregistrement
oRecordset.MoveFirst
'Se place sur le dernier enregistrement
oRecordset.MoveLast
'Se place sur l'enregistrement précédent
oRecordset.MovePrevious
'Se place sur l'enregistrement suivant
oRecordset.MoveNext
'Recule de trois enregistrements
oRecordset.Move -3
'Avance de trois enregistrements
oRecordset.Move 3

Lorsque vous atteignez le dernier enregistrement et que vous utilisez la méthode MoveNext, la propriété EOF est égale à True et la position courante n'est plus un enregistrement. Vous êtes à la fin du recordset et un nouveau déplacement vers l'avant entrainera une erreur d'exécution. (Il en va de même pour BOF et les déplacements en arrière)

Pour parcourir l'ensemble des enregistrements d'un Recordset, vous procéderez ainsi :

'Tant que non fin du recordset
While Not oRecordset.EOF
  'Passer au suivant
  oRecordset.MoveNext
Wend

Les méthodes dont le nom commence par Find permettent d'atteindre un enregistrement dont les données vérifient le critère passé en paramètre. Ce critère correspond à la clause WHERE d'une requête SQL.

La différence entre les diverses méthodes réside dans le sens de la recherche.

• FindNext recherche le prochain enregistrement (à partir de la position courante) vérifiant le critère.
• FindPrevious effectue la même recherche mais vers l'arrière.
• FindFirst trouve le premier enregistrement (à partir du début du jeu d'enregistrement) vérifiant le critère.
• FindLast trouve le dernier enregistrement (à partir de la fin du jeu d'enregistrement).

Ainsi, pour se positionner sur le premier enregistrement dont le champ NomClient commence par T dans un formulaire :

Dim strCritere as string
strCritere="NomClient LIKE " & chr(34) & "T*" & chr(34)
Me.Recordset.FindFirst strCritere

Si aucun enregistrement ne vérifie le critère, la propriété NoMatch du recordset est égale à True.

Exemple :

Dim strCritere as string
strCritere="NomClient LIKE " & chr(34) & "T*" & chr(34)
Me.Recordset.FindFirst strCritere
If Me.Recordset.NoMatch Then Msgbox "Aucun enregistrement n'a été trouvé"

Parfois, vous souhaitez naviguer dans le jeu d'enregistrements puis revenir à la position ou vous étiez avant. La propriété Bookmark du Recrodset retourne un signet vers l'enregistrement. Il s'agit d'un tableau contenant des données de type Byte.

Dim BytPosition() as Byte
BytPosition=oRecordset.Bookmark

Si par la suite, vous souhaitez revenir à cette position, il suffit d'affecter la valeur mémorisée à la propriété Bookmark.

oRecordset.Bookmark=BytPosition

Il est possible de lire les données de l'enregistrement courant à l'aide de la collection Fields. Cette collection fonctionne comme les autres collection DAO et il est possible d'appeler chaque élément par son nom ou par sa position dans la collection.

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("SELECT NumClient,NomClient FROM Client WHERE NumClient=2",dbOpenDynaset)
Msgbox "Le nom du client est : " & Rst.Fields("NomClient").Value

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Ou

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("SELECT NumClient,NomClient FROM Client WHERE NumClient=2",dbOpenDynaset)
Msgbox "Le nom du client est : " & Rst.Fields(1).Value

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

La propriété Value est le membre par défaut d'un objet Field. Vous pouvez donc utiliser :

Msgbox "Le nom du client est : " & Rst.Fields(1)

La modification d'un enregistrement peut se décomposer en 4 étapes :

L'exemple suivant fixe la date de toutes les commandes à aujoud'hui.

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("TblCommande",dbOpenTable)
While Not oRst.EOF
  'Passe en mode modification
  oRst.Edit
  'Affecte la date actuelle
  oRst.Fields("DateCommande").Value=Now()
  'Met à Jour
  oRst.Update
  'Passe au suivant
  oRst.MoveNext
Wend

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Notre exemple réalise un Update massif sur l'ensemble de la table commande. Toutefois ne perdez pas de vue que dans bien des cas, une instruction SQL peut suffir et reste bien plus performante qu'une boucle sur un jeu d'enregistrement.

CurrentDb.Execute "UPDATE TblCommande SET DateCommande=#" & Now() & "#"

La méthode AddNew d'un Recordset permet d'ajouter un enregistrement. Aprés avoir assigné les valeurs aux différents champ, vous devez faire appel à la méthode Update pour mettre à jour les données ou bien à la méthode CancelUpdate pour annuler l'ajout. L'enregistrement nouvellement créé est placé à la fin du jeu d'enregistrement, excepté dans le cas d'un Recordset de type Table où l'enregistrement est placé suivant l'ordre des index de la table. Dans tout les cas, le Recordset revient à sa position d'origine avant l'appel de la méthode Update.

Exemple :

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("TblProduit",dbOpenTable)
'Passe en mode Ajout
oRst.AddNew
'Affecte les différents champs
oRst.Fields("Reference").Value="SRS200"
oRst.Fields("Libelle").Value="Souris optique sans fil"  
'Met à Jour
oRst.Update

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Vous devez affecter chacun des champs dont la propriété Required est égale à True, sans quoi une erreur sera levée. De même vous devez respecter les contraintes d'index que vous avez définit sur la table. Ainsi, une clé primaire ne peut contenir de doublons.

Dans le cas où un des champs est de type NuméroAuto, il est impossible d'affecter une valeur à ce champ. La numérotation automatique est gérée par le moteur Jet. Toutefois, pour des raisons diverses et variées, vous pouvez avoir le besoin de connaitre la nouvelle valeur du NuméroAuto créé. La valeur d'un tel champ est disponible avant l'appel de la méthode Update. Prenons l'exemple d'une table client dont le champ NumClient est auto-incrémenté :

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Dim LngNouvelleValeur as Long
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("TblClient",dbOpenTable)
'Passe en mode Ajout
oRst.AddNew
'Affecte les différents champs
oRst.Fields("NomClient").Value="DUPONT"
oRst.Fields("PrenomClient").Value="Martin"  
'Récupère le nouvel identifiant
LngNouvelleValeur=oRst.Fields("NumClient").Value
'Met à Jour
oRst.Update
'Affiche le numéro client de 
 'l'enregistrement nouvellement créé
Msgbox "Le client " & NouvelleValeur & " a été créé"

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Dans le cas d'un nombre important d'enregistrements à ajouter, un ordre SQL (INSERT) envoyé à la méthode Execute de l'objet Database sera plus performant que de charger un curseur contenant tous les enregistrements en mémoire.

Nous aurions donc avec l'exemple de la souris optique :

Dim StrChaineSQL As String
StrChaineSQL="INSERT INTO TblProduit (Reference,Libelle) VALUES (" & chr(34) & "SRS200" & chr(34) & _
   "," & chr(34) & "Souris optique sans fil" & chr(34) & ")"
CurrentDb.Execute StrChaineSQL

Toutefois, avec cette syntaxe il est impossible de retrouver la valeur d'un champ NuméroAuto lors de l'ajout d'un enregistrement. Certains affirmeront qu'il suffit alors de récupérer la valeur maximum du champ concerné pour ne sélectionner que le dernier enregistrement de la table, toutefois, cela ne garantit pas qu'il s'agisse de l'enregistrement que vous venez d'ajouter. En effet, un autre utilisateur peut avoir ajouté un autre enregistrement immédiatement après vous.

La méthode Delete d'un objet Recordset de type Table ou Dynaset permet de supprimer l'enregistrement courant. Aprés la suppression, l'enregistrement en cours n'est plus défini. Il est considéré comme supprimé et une erreur sera levée si vous tentez d'y accéder. Il vous faut donc modifier la position courante du curseur à l'aide des méthodes MoveNext ou MovePrevious.

L'exemple suivant supprimer toute les commandes du client numéro 13

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur
Set oRst=oDb.OpenRecordset("SELECT * FROM TblCommandes WHERE NumClient=13")
'Parcours le jeu d'enregistrement jusqu'à la fin
While Not oRst.EOF
 'Supprime l'enregistrement
 oRst.Delete
 'Passe au suivant
 oRst.MoveNext
Wend

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Il existe deux façons de procéder pour compter le nombre d'enregistrements d'un Recordset.
La première consiste à utiliser une requete utilisant l'instruction SQL Count et de lire cette valeur.

Ainsi, le nombre de clients habitant à Paris peut être déterminé par :

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
Dim LngNbEnregistrement As Long
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur retournant le nombre de clients résidant à Paris
Set oRst=oDb.OpenRecordset("SELECT Count(*) FROM TblCLients WHERE Ville=" & Chr(34) & "Paris" & Chr(34))
'Lit le résultat
LngNbEnregistrement=oRst.Fields(0).Value

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Notons qu'une requête utilisant la fonction de regroupement Count retourne au moins un enregistrement. De ce fait le curseur ne sera jamais vide à son ouverture, il n'est donc pas obligatoire de tester l'existence d'enregistrement au sein du recordset avant de lire sa première ligne.

La seconde façon de procéder consiste à utiliser la propriété RecordCount du Recordset. Cette propriété renvoie le nombre d'enregistrements d'un recordset de type Table ou le nombre d'enregistrements accédés lorsqu'il s'agit d'un Recordset d'un autre type.

Ainsi, pour compter le nombre d'enregistrements d'un recordset de type table, nous pouvons utiliser :

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
Dim LngNbEnregistrement As Long
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur retournant tous les clients
Set oRst=oDb.OpenRecordset("TblCLients",dbOpenTable)
'Compte les enregistrements
LngNbEnregistrement=oRst.RecordCount

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Dans le cas d'un autre type de Recordset, nous devons utiliser MoveLast afin d'atteindre le dernier enregistrement. La propriété RecordCount retournera alors le nombre d'enregistrements de l'objet.

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
Dim LngNbEnregistrement As Long
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur retournant le nombre de clients résidant à Paris
Set oRst=oDb.OpenRecordset("SELECT * FROM TblCLients WHERE Ville=" & Chr(34) & "Paris" & Chr(34),dbOpenDynaset)
'Atteint le dernier enregistrement
oRst.MoveLast
'Compte les enregistrements accédés (soit le total)
LngNbEnregistrement=oRst.RecordCount

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Il est possible d'ouvrir un nouvel objet Recordset depuis un premier Recordset tout en restreignant la selection des données à l'aide d'un filtre. Pour cela, vous devez spécifier un filtre à la propriété Filter du premier Recordset puis utiliser sa méthode OpenRecordset afin de retourner un nouveau jeu d'enregistrements filtré.

Le filtre à appliquer est une chaîne de caractères correspondant à la clause WHERE d'une requête (sans le WHERE).

Prenons comme exemple une table TblClients dont on ne sélectionne que les clients résidant à Paris.

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
Dim oRstFiltre as DAO.Recordset
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur retournant tous les clients
Set oRst=oDb.OpenRecordset("SELECT * FROM TblClients",dbOpenDynaset)
'Applique le filtre de sélection des habitants de Paris
oRst.Filter="Ville=" & Chr(34) & "Paris" & Chr(34)
'Ouvre un nouveau curseur
Set oRstFiltre=oRst.OpenRecordset
'***************************************
'ici, traitement sur le recordset filtre
'***************************************

'Libération des objets
oRst.Close
oRstFiltre.Close
oDb.Close
Set oRst=Nothing
Set oRstFiltre=Nothing
Set oDb=Nothing

Notons toutefois que dans la majorité des cas, il est plus rapide d'ouvrir un nouvel objet Recordset directement depuis un objet Database en spécifiant une requête SQL complète à l'argument source.

Dim oDb as DAO.Database
Dim oRstFiltre as DAO.Recordset
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre un curseur retournant tous les clients résidant à Paris
Set oRstFiltre=oDb.OpenRecordset("SELECT * FROM TblClients WHERE Ville=" & Chr(34) & "Paris" & Chr(34)",dbOpenDynaset)
'***************************************
'ici, traitement sur le recordset filtre
'***************************************

'Libération des objets
oRstFiltre.Close
oDb.Close
Set oRstFiltre=Nothing
Set oDb=Nothing

La lecture par bloc est un point trés important mais malheureusement fort oublié de DAO. En effet, la méthode GetRows permet de retourner un tableau possédant un nombre donné d'enregistrements. Ces enregistrements sont extraits à partir de la position courante du Recordset.

La syntaxe est la suivante :

Set varArray = recordset.GetRows (numrows)

VarArray est un tableau à deux dimensions recevant les données. Le premier indice correspond au champ et le second au numéro de l'enregistrement.

Recordset est le recordset possédant les données.

Numrows correspond au nombre d'enregistrements à lire.

Dans le cas où le nombre d'enregistrements disponibles est inférieur au nombre à extraire, la méthode GetRows retourne un tableau dont le nombre d'élément sera égal au nombre d'enregistrements disponibles. Il est donc conseillé d'utiliser la méthode UBound pour connaitre la borne supérieure du tableau.

Après extraction, la position courante du Recordset est définit sur l'enregistrement suivant le dernier lu, vous pouvez donc enchaîner une autre lecture vers l'avant. Dans le cas où vous souhaiteriez lire les X enregistrements précédents, il vous faut atteindre le premier enregistrement à lire à l'aide de l'instruction Move. (Sans toutefois atteindre la position BOF)

Lorsque le nombre de données à lire devient important, il s'avère que l'utilisation de la méthode GetRows pour accéder aux données représente un gain de rapidité pouvant atteindre 20 %.

Cet exemple met en oeuvre l'utilisation de la méthode GetRows afin de réaliser un formulaire affichant les enregistrements par blocs de 10. Les données proviennent de la table Clients de la base de données Comptoir.mdb (Répertoire samples d'Access). De cette table, nous conserverons uniquement les champs suivants :

Code Client, Société, Ville, Pays

Notre formulaire ce compose ainsi :

Chaque zone de texte est indépendante et possède un nom égal à celui de sa colonne, concaténé avec le numéro de l'enregistrement quelle affichera.

Nous utiliserons deux variables dans la portée du formulaire :

Dim oRstClient As DAO.Recordset  'Stocke le curseur
Dim intnbLus As Integer   'Stocke le nb d'enregistrements lus la dernière fois

Le principe est simple, à l'ouverture du formulaire, nous chargons le Recordset et affichons les 10 premiers enregistrements.

Private Sub Form_Load()
Dim oDb As DAO.Database
'Instancie la base de données
Set oDb = CurrentDb
'Ouvre le recordset
Set oRstClient = oDb.OpenRecordset("Clients", dbOpenTable)
'Lit les 10 premiers
LectureVersLAvant
End Sub

Private Sub LectureVersLAvant()
On Error GoTo err
RemplirZoneTexte oRstClient.GetRows(10)
Exit Sub
err:
'Si on est sur le dernier enregistrement
'alors ne rien faire, sinon avertir
If err.Number <> 3021 Then
 MsgBox "Une erreur est survenue pendant la lecture des données", vbCritical, "Erreur"
End If
End Sub

La procédure RemplirZonetexte boucle sur chaque ligne du tableau et affiche la valeur du champ dans la zone de texte correspondante pour la ligne sélectionnée. Les autres lignes sont ensuites masquées.

Sub RemplirZoneTexte(Tableau As Variant)
Dim I As Integer
'Récupère le nombre d'enregistrements Lus
intnbLus = UBound(Tableau, 2) + 1
'affecte les valeurs aux zones de texte
For I = 0 To intnbLus - 1
  'Affiche le code client
  Controls("TCodeClient" & I + 1) = Tableau(0, I)
  Controls("TCodeClient" & I + 1).Visible = True
  'Affiche la societe
  Controls("TSociete" & I + 1) = Tableau(1, I)
  Controls("TSociete" & I + 1).Visible = True
  'Affiche la ville
  Controls("TVille" & I + 1) = Tableau(2, I)
  Controls("TVille" & I + 1).Visible = True
  'Affiche le pays
  Controls("TPays" & I + 1) = Tableau(3, I)
  Controls("TPays" & I + 1).Visible = True
Next I
'Masque les autres zones de textes
For I = intnbLus + 1 To 10
  'Masque le code client
  Controls("TCodeClient" & I).Visible = False
  'Masque la societe
  Controls("TSociete" & I).Visible = False
  'Masque la ville
  Controls("TVille" & I).Visible = False
  'Masque le pays
  Controls("TPays" & I).Visible = False
Next I
End Sub

Les déplacements vers l'arrière sont plus complexes étant donné que si nous avons lu les 20 premiers, la position courante du Recordset est définie à 21 et les enregistrements 11 à 20 sont affichés. Or, la plage souhaitée est celle des lignes 1 à 10. Nous devons donc reculer du nombre d'enregistrements lu la précédente fois et nous positionner 10 enregistrements en arrière pour commencer la lecture. Toutefois, il se peut que ce nombre de sauts excède le nombre d'enregistrements disponibles vers l'arrière. Le plus simple est alors d'intercepter l'erreur levée (3021) afin de ne pas stopper l'éxecution et de se positionner sur le premier enregistrement du curseur.

Private Sub LectureVersLArriere()
On Error GoTo err
'Recule du nombre d'enregistrements nécessaire
oRstClient.Move -1 * intnbLus - 10
RemplirZoneTexte oRstClient.GetRows(10)
Exit Sub
err:
Select Case err.Number
  'Si on a trop reculé alors, se positionner sur le premier
  Case 3021: oRstClient.MoveFirst
  'Sinon, Avertir
  Case Else: MsgBox "Une erreur est survenue pendant la lecture des données", vbCritical, "Erreur"
End Select
End Sub

Vous pouvez aisément obtenir une interface ressemblant à ceci :

Vous pouvez télecharger le fichier exemple ici.

Type : Long

La propriété AbsolutePosition correspond à un numéro représentant la position courante dans le Recordset. Le premier enregistrement possède la position zéro. En affectant à cette propriété une valeur comprise entre 0 et le nombre d'enregistrements - 1, le curseur va se déplacer de telle sorte à atteindre l'enregistrement spécifié. Toutefois, privilégiez l'utilisation de la propriété Bookmark pour mémoriser une position et y retourner. Dans le cas où le jeu d'enregistrements est vide, cette propriété renvoie -1.

Elle ne s'applique pas aux Recorset de type Table (dbOpenTable) ni En avant seulement (dbOpenForwardOnly).

Lecture seule.

Type : Boolean

Lorsque la propriété BOF d'un Recordset est égale à True, cela signifie que la position courante du curseur est définie avant le premier enregistrement.

Cette propriété s'applique à tous les types de Recordset.

Type : Variant

La propriété Bookmark correspond à un signet identifiant de manière unique l'enregistrement au sein du Recordset. Cette propriété est à utiliser pour mémoriser une position ou se déplacer dans le jeu. Un exemple est disponible dans la section intitulée : 5.3.3 Mémoriser une position.

Cette propriété ne s'applique pas aux Recordset de type En avant seulement (dbOpenForwardOnly).

Les signets ne sont pas utilisables lorsque la propriété Bookmarkable est égale à False.

Lecture seule.

Type : Variant

La propriété Bookmarkable renvoie True lorsque le curseur accepte les signets (Ce qui est automatiquement le cas pour une base de données Access). Si vous travailler en liaison avec certains SGBD, il est nécessaire de tester cette valeur avant d'utiliser la propriété Bookmark.

Cette propriété ne s'applique pas Recordset de type En avant seulement (dbOpenForwardOnly).

Type : Long

La propriété CacheSize correspond au nombre d'enregistrements stockés en mémoire cache. Sa valeur doit être comprise entre 5 et 1200 sans dépasser la quantité de mémoire disponible. La valeur 0 désactive l'utilisation de la mémoire cache.

Cette propriété est utilisable uniquement avec les Recordset de type dynamique ou instantané et lorsque les données proviennent d'une source ODBC.

Type : String

La valeur de la propriété CacheStart correspond au signet du premier enregistrement de l'objet Recordset à placer en mémoire cache. Vous pouvez utiliser le signet de tout enregistrement pour définir la propriété CacheStart.

Cette propriété est utilisable uniquement avec les Recordset de type dynamique ou instantané et lorsque les données proviennent d'une source ODBC.

Cette propriété étant très bien documentée dans l'aide, je vous renvoie vers cette dernière pour de plus amples détails

Lecture seule.

Type : Connection

Dans un environnement ODBC Direct, la propriété Connection renvoie l'objet Connection depuis lequel le Recordset a été ouvert.

Cette propriété n'est pas disponible pour les curseurs de type Table.

Lecture seule.

Type : Date

Pour un Recordset de type Table, cette propriété retourne la date de création de la table.

Lecture seule.

Type : Long

La propriété EditMode renvoie une valeur indiquant l'état de modification de l'enregistrement courant.

Il s'agit d'une des constantes suivantes :

Cette propriété s'applique à tous les types de Recordset.

Ainsi dans un code complexe, il est possible de connaitre le statut de votre Recordset. Ainsi, pour savoir si nous sommes sur le point de valider l'ajout d'un enregistrement, nous devrons évaluer :

If oRecordset.EditMode=dbEditAdd then Msgbox "Un ajout est en cours"

Toutefois, si votre code est bien structuré, vous devez être capable de connaitre le statut de votre curseur à chaque ligne de code. L'utilisation de cette propriété doit donc se limiter a des cas extrèmes, ou pour debugguer un code existant.

Lecture seule.

Type : Boolean

Lorsque la propriété EOF d'un Recordset est égale à True, cela signifie que la position courante du curseur est définie après le dernier enregistrement.

Cette propriété s'applique à tous les types de Recordset.

Lecture seule.

Type : Collection

Cette collection regroupe l'ensemble des champs du Recordset. De plus amples informations sur les objets Field sont disponibles dans la section 4.4 L'objet Field.

Cette propriété s'applique à tous les types de Recordset.

Type : String

La propriété Filter permet de spécifier un filtre qui sera appliqué lors de l'appel de la méthode OpenRecordset. Il s'agit de la clause WHERE d'une requête SQL (sans le mot clé WHERE). De plus amples informations sont disponibles dans la section 5.4.6 Filtrer les données.

Type : String

La propriété Index correspond au nom de l'index utilisé dans un Recordset pour rechercher les enregistrements dans un Recordset de type Table exclusivement.

Lecture seule.

Type : Variant

Cette propriété retourne un signet pointant vers le dernier enregistrement modifié ou ajouté au jeu d'enregistrements. Vous pouvez atteindre ensuite cet enregistrement en affectant ce signet à la propriété Bookmark.

Exemple :

With oRecordset
.Bookmark=.LastModified
End With

Cette propriété s'applique à tous les types de Recordset hormis le type En avant seulement (dbOpenForwardOnly).

Lecture seule.

Type : Date

La propriété LastUpdated retourne la date à laquelle la table d'un Recordset a été modifiée pour la dernière fois.

Elle n'est appliquable qu'aux objets Recordset de type Table.

Type : Boolean

Cette propriété définit le type de verrouillage utilisé par le Recordset. Lorsque'elle est égale à True (Valeur par défaut), la page est verrouillée dés l'appel de la méthode Edit. Dans le cas contraire (False), la page d'enregistrements est verrouillée uniquement lors de l'appel de la méthode Update.

Type : String

La propriété Name représente le nom de l'objet. Cette propriété est inutile dans l'utilisation des Recordset étant donné que ceux-ci ne sont pas nommés. Cette propriété est en fait égale aux 256 premiers caractères de l'argument Source utilisé lors de la méthode Database.OpenRecordset.

Lecture seule.

Type : Boolean

La propriété NoMatch est égale à True lorsque l'une des méthodes Find.... n'a pas trouvé d'enregistrement vérifiant le critère.

Type : Single

La propriété PercentPosition correspond à une valeur 0 à 100 indiquant la position approximative dans le Recordset. Bien que vous puissiez la définir pour vous déplacer, elle est de faible intérêt en écriture car approximative.

Elle n'est appliquables qu'aux Recordset de type Table, Dynaset et instantané.

Vous devez avoir atteint le dernier enregistrement afin que sa valeur soit significative par rapport à la globalité du Recordset. Sinon, cette propriété ne se base pas sur le nombre d'enregistrements total mais parcourus. Pour atteindre le dernier enregistrement, vous pouvez utiliser la méthode MoveLast.

Lecture seule.

Type : Collection

Cette collection regroupe l'ensemble des propriétés du Recordset, comme spécifié dans la section 4.2 Propriétés spécifiques.

Lecture seule.

Type : Long

La propriété RecordCount retourne le nombre d'enregistrements total d'un Recordset de type Table ou le nombre d'enregistrements auxquels vous avez eu accès dans un Recordset d'un autre type.

Elle n'est pas appliquable aux Recordset de type En avant seulement (dbOpenForwardOnly)

De plus amples informations sur cette propriété sont disponible dans la section intitulée 5.4.5 Compter les enregistrements

Lecture seule.

Type : Long

Lorsque cette propriété est égale à True, cela signifie qu'il est possible de mettre les données à jour en réexécutant la requête à l'aide de Requery. En d'autres thermes, elle indique si la méthode Requery est supportée par le Recordset. Dans le cas contraire, vous devrez réouvrir le curseur à l'aide de la méthode OpenRecordset de l'objet Database ou QueryDef utilisé pour y puiser les données.

Elle est utilisable sur tout type de Recordset, toutefois, elle renvoie toujours False pour un Recordset de type Table.

Type : String

La propriété Sort permet de spécifier un ordre de tri qui sera appliqué lors de l'appel de la méthode OpenRecordset. Il s'agit de la clause ORDER BY d'une requête SQL (sans le mot clé ORDER BY). Ainsi, il est possible d'instancier un nouvel objet Recordset trié depuis un autre :

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
Dim oRstTrie as DAO.Recordset
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur retournant tous les clients
Set oRst=oDb.OpenRecordset("SELECT Ville,NomClient,PrenomClient FROM TblClients" _
   ,dbOpenDynaset)
'Tri sur la ville et le nom du client
oRst.Sort="Ville,NomClient"
'Ouvre un nouveau curseur
Set oRstTrie=oRst.OpenRecordset
'*************************************
'ici, traitement sur le recordset trié
'*************************************

'Libération des objets
oRst.Close
oRstTrie.Close
oDb.Close
Set oRst=Nothing
Set oRstTrie=Nothing
Set oDb=Nothing

Cette propriété ne s'applique qu'aux Recordset de type Dynaset et Instantané.

Notons toutefois que dans la majorité des cas, il est plus rapide d'ouvrir un nouvel objet Recordset directement depuis un objet Database en spécifiant une requête SQL complète à l'argument source.

Lecture seule.

Type : Boolean

Dans un environnement ODBC Direct, la propriété StillExecuting renvoie True si la requête d'ouverture du Recordset est encore en cours d'exécution.

Lecture seule.

Type : Boolean

Lorsque la propriété Transactions d'un objet Recordset est égale à True, cela signifie que vous pouvez utiliser les transactions sur ce Recordset. Pour démarrer une transaction, utilisez la méthode BeginTrans de l'objet Workspace ayant créer le curseur. Invoquez ensuite la méthode CommitTrans pour mettre à jour les données ou Rollback pour annuler.

Exemple :

Dim oRst as DAO.Recordset
Dim oDb as DAO.Database
Set oDb=CurrentDb
Set oRst=oDb.OpenRecordset("TblCommande",dbOpenTable)
'Demarre la transaction
DBEngine.Workspaces(0).BeginTrans
While Not oRst.EOF
  'Passe en mode modification
  oRst.Edit
  'Affecte la date actuelle
  oRst.Fields("DateCommande").Value=Now()
  'Met à Jour
  oRst.Update
  'Passe au suivant
  oRst.MoveNext
Wend
'Demande confirmation
If Msgbox("Etes vous sûr de vouloir continuer")=VbYes
  'Si oui, mettre à jour
  DBEngine.Workspaces(0).CommitTrans
Else
  'Sinon, annuler
  DBEngine.Workspaces(0).Rollback
End if

'Libération des objets
oRst.Close
oDb.Close
Set oRst=Nothing
Set oDb=Nothing

Lecture seule.

Type : Long

La propriété Type renvoie le type de curseur utilisé conformément aux informations spécifiées dans la section : 5.2 Les différents types de Recordset.

Lecture seule.

Type : Boolean

Lorsque la propriété Updatable est égale à False, il est impossible de mettre à jour les données du Recordset.

Type : Long

La propriété UpdateOptions correspond au mode de création d'une clause WHERE dans une requête UPDATE lors d'une mise à jour par lot dans un environement ODBC Direct. Dans certains cas, il est ainsi possible de contourner un déclencheur Update du SGBD distant en forçant le moteur de base de données à remplacer une requête UPDATE par une requête DELETE suivie d'une requête INSERT. Toutefois, cette propriété ne sera pas d'avantage documentée dans ce document et je vous propose de consulter l'aide Access pour plus de détails.

Lecture seule.

Type : String

La propriété ValidationRule définit la règle de validation qui sera utilisée pour valider les données lors de l'appel de la méthode Update.

Lecture seule.

Type : String

La propriété ValidationText correspond au message qui sera affiché lors d'une mise à jour si les données ne vérifie pas la règle spécifiée dans ValidationRule.

La méthode AddNew permet d'ajouter un nouvel enregistrement au Recordset. Elle est illustrée dans la section 5.4.3 Ajouter un enregistrement.

Exemple :

With oRecordset
 .AddNew
 .Fields("Nom")="Toto"
 .Update
End With

La méthode CancelUpdate est à invoquer après les méthodes Edit ou Addnew pour annuler la mise à jour. Dans le cas d'un ajout, la position du Recordset est redéfinie à ce qu'elle était avant l'appel de AddNew.

Exemple :

With oRecordset
 .AddNew
 .Fields("Nom")="Toto"
 'Annule l'insertion
 .CancelUpdate
End With

La méthode Clone retourne un Recordset identique à celui sur lequel elle est appliquée. Le recordset cloné ne possède pas d'enregistrement courant vous devez alors vous positionner sur l'enregistrement de votre choix. Notons que les signets sont interchangeables entre chaque Recordset. Ainsi, il est possible de positionner le clone au même endroit que la source avec :

Dim oRst as DAO.Recordset
Dim oRstClone as DAO.Recordset
'****************************
'ici Code d'ouverture de Rst
'****************************

'Copie du recordset
Set oRstClone=oRst.Clone
'Définit le même enregistrement courant
oRstClone.Bookmark=oRst.Bookmark

Une fois oRst cloné, vous pouvez le fermer sans aucune incidence sur RstClone.

Cette méthode n'est pas compatible avec les objets Recordset de type En avant seulement (dbOpenForwardOnly)

La méthode Close ferme le Recordset. Toutefois, celle-ci ne libère pas la variable objet de la mémoire. Pour la libérer, vous devez attendre la fin de la procédure et la destruction de la variable ou affecter Nothing à cette dernière.

Exemple :

oRecordset.Close
Set oRecordset=Nothing

La méthode CreateQueryDef copie l'objet QueryDef utilisé pour ouvrir le Recordset. Celui-ci doit impérativement avoir été ouvert à l'aide de la méthode OpenRecordset d'un objet QueryDef.

Syntaxe :

Set querydef = oRecordset.CopyQueryDef

Cette méthode ne s'applique pas aux Recordset de type Table (Puisqu'ils ne sont pas ouverts depuis un objet QueryDef).

La méthode Delete supprime un enregistrement du Recordset. Elle est illustrée dans la section 5.4.4 Supprimer un enregistrement. Une fois l'enregistrement supprimé, la position du Recordset n'est plus valide, vous devez donc atteindre un autre enregistrement.

Exemple :

With oRecordset
 .Delete
 Msgbox "Suppression réussie"
 .MoveNext
End With

La méthode Edit copie l'enregistrement dans le tampon et passe le Recordset en mode acEditInProgress afin que vous puissiez modifier les données.

Un exemple d'utilisation est disponible dans la section : 5.4.2 Modifier un enregistrement.

Ces méthodes sont à utiliser pour trouver des enregistrements au sein du jeu. Une section complète leur est dédiée : 5.3.2 Trouver un enregistrement.

Elles ne sont disponibles que pour les Recordset de type Dynaset et Instantané.

La méthode GetRows lit et retourne dans un tableau à deux dimensions X enregistrements à partir de l'enregistrement courant (X étant un nombre positif spécifié dans le seul argument de GetRows). Un exemple de formulaire lisant les données par bloc est disponible dans la section 5.5 Lecture par bloc.

Ces méthodes sont à utiliser pour se déplacer au sein du jeu d'enregistrements comme indiqué dans la section 5.3.1 Se déplacer dans un Recordset.

Elles sont disponibles pour tout type de Recordset hormis les méthodes MoveFirst et MovePrevious qui opèrent des déplacements vers l'arrière et qui sont donc incompatibles avec les curseurs de type En avant seulement (dbOpenForwardOnly).

La méthode OpenRecordset instancie un nouvel objet Recordset possédant la même source de données que le Recordset original mais en tenant compte des éventuelles propriétés Filter et Sort.

Voici un exemple d'utilisation appliquant un filtre :

Dim oDb as DAO.Database
Dim oRst as DAO.Recordset
Dim oRstFiltre as DAO.Recordset
'Instancie la base de données
Set oDb=CurrentDb
'Ouvre le curseur retournant tous les clients
Set oRst=oDb.OpenRecordset("SELECT * FROM TblClients",dbOpenDynaset)
'Applique le filtre de sélection des habitants de Paris
oRst.Filter="Ville=" & Chr(34) & "Paris" & Chr(34)
'Ouvre un nouveau curseur
Set oRstFiltre=oRst.OpenRecordset
'***************************************
'ici, traitement sur le recordset filtre
'***************************************

Cette méthode n'est pas disponible pour les Recordset de type En avant seulement (dbOpenForwardOnly).

La méthode Requery met à jour les données contenues dans un objet Recordset en exécutant de nouveau la requête sur laquelle l'objet est fondé.

Notons que certains SGBD ne supportent pas l'utilisation de la méthode Requery. Dans ce cas, vous pouvez interroger la propriété Restartable afin de connaître si Requery est applicable.

La méthode Update permet d'enregistrer les données depuis le tampon de copie vers la base de données. Cette méthode est à invoquer aprés l'affectation des différents champs suite à un appel à la méthode Edit ou AddNew. Pour ne pas enregistrer les données, vous devez utiliser la méthode CancelUpdate.

Pour de plus amples informations, vous pouvez consulter la section 5.4.2 Modifier un enregistrement.