Connexion aux données en Visual Basic Access

Pour partager cette vidéo sur les réseaux sociaux ou sur un site, voici son url :


Sujets que vous pourriez aussi aimer :


Connexion aux données en Visual Basic Access

Dans cette formation, nous allons apprendre à attaquer les données de base de données en Visual Basic Access. Nous avons vu dans une précédente formation comment extraire les données de tables, grâce à des requêtes liées dynamiquement à des contrôles de formulaire. Cette fois, nous allons découvrir quels sont les objets de programmation pour parcourir les enregistrements d'une base de données. C'est donc un code seul sur événement qui permettra de récupérer les informations des champs, selon les critères définis par l'utilisateur, depuis un formulaire graphique.

Formulaire de recherche Access
Pour bâtir un code d'extraction de données, nous allons démarrer avec une base de données des idées de sorties, classées par activités et départements. Il s'agit de la même base de données que celle exploitée dans la formation précédente.

• Télécharger la base de données sorties.accdb en cliquant sur son lien,
• L'ouvrir dans Access et cliquer sur le bouton Activer le contenu si nécessaire,

Cette base de données est constituée de trois tables dont la plus importante, la table societes. Elle propose de même un formulaire qui est préconçu pour extraire des données automatiquement. Ici, nous avons besoin d'un formulaire graphique adapté aux spécificités du code VBA. Nous souhaitons que l'utilisateur puisse rechercher des idées de sorties par mot clé. S'il le souhaite, il pourra recouper ce critère en filtrant sur les départements. Donc nous allons construire un formulaire indépendant avec une zone de saisie pour les mots clés, une liste déroulante pour filtrer les départements et une zone de texte pour afficher les résultats de l'extraction de données par le code Visual Basic Access.

• Cliquer sur l'onglet Créer en haut de la fenêtre Access pour activer son ruban,
• Dans la section Formulaires, cliquer sur le bouton Création de formulaire,

Grâce à ce choix, Access livre un formulaire vide de contenu, en mode conception, prêt à recevoir les contrôles pour être personnalisé. C'est pourquoi les rubans dédiés Création, Organiser et Format apparaissent.

• Si elle n'est pas visible, cliquer sur le bouton Feuille de propriétés dans le ruban Création,

Nous pourrons ainsi nommer les objets et leur attacher des événements pour déclencher du code Visual Basic. VBA est un langage de programmation orienté objets. C'est donc par leur nom que nous accèderons à leurs propriétés et méthodes.

• A l'aide des contrôles du ruban Création, ajouter une Zone de liste déroulante sur le formulaire,
• Dans l'onglet Autres de sa feuille de propriétés, régler sa propriété Nom sur : liste_deroulante,
• Sur sa droite, ajouter une zone de texte à l'aide des contrôles du ruban,
• La nommer : mot_cle depuis sa feuille de propriétés,
• Sur sa droite, ajouter un contrôle Bouton,
• Le nommer : chercher,
• Puis, dans l'onglet Format, régler sa propriété Légende sur : Rechercher,

Pour un bouton, la propriété Légende est celle qui permet de modifier le texte ou l'intitulé affiché.

• Sous ces trois contrôles, ajouter une nouvelle zone de texte sur une hauteur de plusieurs lignes,
• La nommer : resultat,
• Puis dans l'onglet Format, régler sa propriété Barre défilement sur : Verticale,

Un ascenseur apparaîtra si le contenu de l'extraction dépasse les capacités de la zone de saisie. Il permettra de faire défiler chacune des lignes.

• Enregistrer ce formulaire sous le nom : Formulaire_connexion,
• Le fermer puis double cliquer sur son nom depuis le volet gauche des objets Access,

Nous affichons ainsi le formulaire en mode exécution. Ce dernier n'optimise pas forcément l'espace qu'il lui est proposé sur l'écran. Pour pallier ce défaut, nous allons déclencher une marco au chargement, qui forcera le formulaire à optimiser l'espace.

• Dans le ruban Accueil, cliquer sur la flèche du bouton Affichage,
• Dans la liste, choisir Mode Création,
• Activer l'onglet Evénement de la feuille de propriétés,
• En haut de la feuille, choisir l'objet Formulaire à l'aide de la liste déroulante,
• Cliquer sur le bouton de son événement Sur chargement,
• Dans la fenêtre qui suit, choisir générateur de macro et valider,

• Dans l'éditeur de macro, choisir l'action AgrandirFenêtre avec la liste déroulante,
• Enregistrer les modifications (CTRL + S) et fermer l'éditeur de macro (CTRL + W),
• De retour sur le formulaire, enfoncer la touche F5 pour l'exécuter,

Le formulaire s'ouvre et occupe désormais tout l'espace qui lui est proposé. La macro nous a permis de déclencher une action automatisée sur ordre. L'événement intercepté en l'occurrence ici est l'ouverture du formulaire, son chargement. Les macros peuvent s'empiler pour exécuter de nombreux traitements.

• Fermer le formulaire en cliquant sur la croix de son onglet,

Données sources des contrôles de formulaire
Avant de débuter le code VBA qui permettra de parcourir les données à la recherche des enregistrements qui correspondent aux critères, nous dévons réaliser un dernier réglage. Il s'agit de charger la liste déroulante des départements proposés dans la table societes. Ces départements sont répétés à de nombreuses reprises étant donné que beaucoup d'activités de sorties sont référencées dans un même département. Nous devons donc réaliser une extraction sans doublons à l'aide d'une requête. Puis nous utiliserons cette requête comme source de données de la liste déroulante.

• Dans le ruban Créer, cliquer sur le bouton Création de requête,
• Dans la fenêtre qui suit, sélectionner la table societes,
• Cliquer sur le bouton Ajouter puis sur le bouton Fermer,
• Cliquer sur la flèche du bouton Affichage dans le ruban Créer dédié aux requêtes,
• Dans la liste, choisir Mode SQL,

Le langage SQL permet d'extraire les données d'une base grâce à sa syntaxe de requêtage. La requête présente par défaut : SELECT FROM societes permet d'extraire toutes les informations de la table source. Les mots clés SQL sont indiqués en majuscules. SELECT car il s'agit d'une requête sélection. FROM pour indiquer à partir de quelle table l'extraction doit se faire.

• Modifier la requête SQL comme suit :

SELECT DISTINCT societes_departement FROM societes;

Le mot clé DISTINCT suivi du nom du champ (societes_departement) permet de réaliser une extraction sans doublons sur ce dernier.

• Enregistrer la requête (CTRL + S) sous le nom : liste_departements,
• Puis, la fermer en cliquant sur la croix de son onglet,
• Afficher le formulaire Formulaire_connexion en mode création,
• Sélectionner la liste déroulante,
• Activer l'onglet Données de sa feuille de propriétés,
• Pour sa propriété Contenu, choisir l'objet liste_departements,

Nous relions ainsi la liste déroulante à la requête que nous venons de créer. Comme la requête affiche les départements de la table source sans doublons, la liste déroulante restituera ce contenu extrait.

• Enregistrer les modifications (CTRL + S),
• Exécuter le formulaire (F5),

Comme vous le constatez en déployant la liste déroulante, tous les départements sont proposés à la sélection. Ils pourront donc servir de critère de recherche pour la connexion aux données en Visual Basic.


Connexion aux bases de données en VBA
Dans un premier temps, nous souhaitons apprendre et découvrir les objets Visual Basic Access qui permettent d'établir la connexion avec une source. L'objectif, pour débuter simplement, est de réaliser un petit code qui fournit un résultat de recherche, en fonction d'un mot clé tapé par l'utilisateur, depuis le formulaire.

• Afficher le formulaire en mode création,
• Sélectionner le bouton, puis activer l'onglet Evénement de sa feuille de propriétés,
• Cliquer sur le bouton de son événement Au clic,
• Dans la boîte de dialogue qui suit, choisir Générateur de code et valider,

Nous basculons dans l'éditeur de code Visual Basic, entre les bornes de la procédure événementielle : chercher_Click(). Toutes les lignes que nous ajouterons dans cette procédure se déclencheront au clic sur le bouton. La connexion aux bases de données peut se faire grâce à un protocole de communication. Il s'agit d'une sorte de pilote qui permet à un code VBA de manipuler les données. Ce protocole est une DLL nommée DAO ou ADO pour ActiveX Data Objects. Elle contient tous les objets pour établir la connexion avec les données. Nous devons y faire référence pour accéder à ces dernières. Chaque objet, pour être appelé, doit être préfixé du mot clé DAO. Alors la librairie proposera ses objets de connexion aux données. Plus simple, pour éviter de préfixer chaque instruction de code, nous allons ajouter la référence à cette bibliothèque une bonne fois pour toutes, depuis l'éditeur.

• Cliquer sur le menu Outils en haut de l'éditeur de code,
• Dans la liste, choisir Références,
• Cocher la case Microsoft ActiveX Data Objects 6.1 Library par exemple et valider,

Pour éviter tout conflit, il peut être nécessaire de décocher une référence plus ancienne déjà présente comme Microsoft ActiveX Data Objects 2.1 Library.


Pour manipuler les données d'une table, nous avons tout d'abord besoin de deux objets. Nous devons déclarer un objet base de données (Database) pour faire référence à la base en cours. Ainsi, nous pourrons pointer sur les enregistrements d'une table de cette base. Nous devons donc déclarer un objet permettant de désigner un enregistrement (Recordset).

• Entre les bornes de la procédure événementielle, ajouter les deux déclarations suivantes :

Dim ligne As Recordset: Dim base As Database

Comme nous l'avait appris la formation VBA Excel sur la déclaration de variables, le mot clé Dim permet d'initialiser cette déclaration, suivi d'un nom explicite pour la variable. As est le mot clé qui permet d'annoncer le typage. Ici les deux variables sont déclarées comme deux variables objets. Cela signifie qu'elles disposeront de propriétés et méthodes pour manipuler les données de connexion. La variable ligne est déclarée comme un objet Recordset pour parcourir les enregistrements. La variable base est déclarée comme un objet Database pour désigner la base de données.

Nous avons besoin de deux autres variables. La première doit stocker le mot clé saisi par l'utilisateur. Elle doit donc mémoriser un texte et nous devons la déclarer comme un String. La seconde permettra de réaliser un test pour savoir si l'occurrence de ce mot clé est trouvée en parcourant la base de données. Elle doit mémoriser une valeur entière qui correspond à la position de l'occurrence dans la chaîne. Nous devons donc la déclarer comme un Integer.

• A la suite des déclarations précédentes, ajouter les déclarations suivantes :

Dim cherche As String: Dim position As Integer

Si aucun mot clé n'est saisi bien que l'utilisateur ait cliqué sur le bouton, la recherche n'a pas lieu de débuter et le programme doit donc s'arrêter. Il s'agit donc de vérifier si le contenu de la zone de texte (mot_cle) est vide ou non. Ces tests s'effectuent grâce à l'instruction If que nous avons apprise en VBA Excel pour gérer les conditions.

• A la suite du code, ajouter l'instruction suivante :

If(IsNull(mot_cle.Value)) Then Exit Sub

La fonction VBA IsNull que nous avions utilisée lors de la formation VBA Access pour extraire les données, permet de tester si le contenu de la variable passée en paramètre (mot_cle.Value), est vide ou non. Il s'agit d'une fonction booléenne. Si le test est concluant, elle renvoie Vrai (True), donc validé par l'instruction If. Auquel cas (Then), nous mettons fin à l'exécution du programme grâce aux mots clés Exit Sub. Nous pourrions aussi ajouter un MsgBox pour afficher un message à l'utilisateur afin de l'inciter à corriger le défaut. Il s'agit maintenant d'initialiser les variables. Pour ce faire :

• Ajouter les deux affectations suivantes, à la suite du code :

cherche = mot_cle.Value
resultat.Value = ""

Nous stockons l'information saisie par l'utilisateur (mot_cle.Value) dans la variable cherche, que nous avions déclarée comme un String, en connaissance de cause. Puis, nous vidons le potentiel contenu de la zone d'extraction resultat (resultat.Value = "") au cas où une précédente recherche ait déjà été effectuée. Il s'agit maintenant d'initialiser les variables objets pour manipuler la base de données par le code. Pour ce faire :

• Ajouter les deux lignes de code suivantes :

Set base = Application.CurrentDb
Set ligne = base.OpenRecordset("societes", dbOpenTable, dbReadOnly)

Une variable objet s'initialise nécessairement préfixée du mot clé Set, contrairement à une variable classique. Nous exploitons la méthode CurrentDb de l'objet VBA Application pour faire pointer l'objet base, sur la base de données en cours. Puis nous utilisons la méthode OpenRecordset de l'objet base ainsi affecté, pour faire pointer l'objet ligne sur les enregistrements de la table passée en argument. Le seul argument obligatoire de la méthode OpenRecordset est le premier, le nom de la table. La constante dbOpenTable passée en deuxième paramètre, permet d'indiquer le type d'objet à ouvrir, une table ici. Enfin nous définissons le type d'accès en lecture seule (dbReadOnly), pour ne pas risquer d'endommager les données. Comme toujours, la touche F1 du clavier sur une méthode sélectionnée depuis l'éditeur, conduit sur l'aide en ligne qui donne toutes les précisions quant aux arguments à définir.

Grâce à l'objet Recordset, nous sommes désormais en mesure d'accéder aux enregistrements de la table. De fait, nous sommes tout d'abord capables de connaître leur nombre pour savoir si l'exécution doit se poursuivre. De même, nous sommes capables de nous positionner sur le premier d'entre eux pour démarrer la lecture d'informations. Selon ce constat :

• Ajouter les deux lignes de code suivantes :

If ligne.RecordCount = 0 Then Exit Sub
ligne.MoveFirst

RecordCount est une propriété d'un objet Recordset permettant de connaître le nombre d'enregistrements de la table, à laquelle l'objet est connecté. Ensuite, la méthode MoveFirst de l'objet Recordset ligne, permet de placer le pointeur de lecture, sur le premier enregistrement de la table.

Il s'agit maintenant de réaliser une boucle de traitement afin de parcourir un à un, tous les enregistrements de la table. Cette boucle ne doit pas s'arrêter, tant que la fin de la table n'est pas atteinte. C'est pourquoi, nous allons utiliser une boucle Do avec la propriété EOF (End Of File) de l'objet Recordset, pour lire jusqu'à la fin du fichier. Nous avions utilisé cette technique lors de l'accès séquentiel aux fichiers en VBA Excel, pour importer des données.

• Ajouter les trois lignes de code suivantes, pour initialiser la boucle de traitement :

Do
ligne.MoveNext
Loop Until ligne.EOF = True

Les tests pour extraire l'information de base de données, correspondant à la demande utilisateur depuis le formulaire, devront être réalisés entre les bornes de cette boucle. La boucle Do se borne grâce au mot clé Loop. Suivi de l'instruction Until ligne.EOF = True, nous indiquons que l'exécution doit se poursuivre jusqu'au dernier enregistrement (ligne.EOF). Pour qu'à chaque passage le pointeur de l'objet Recordset soit placé sur l'enregistrement suivant, nous utilisons la méthode MoveNext de l'objet ligne.

Nous considérons que la recherche doit se faire sur le nom de l'activité. A chaque passage dans la boucle, nous devons donc réaliser un test sur le champ societes_nom de l'enregistrement en cours de lecture. Si l'information concorde, elle doit être restituée dans la zone resultat qui sert d'affichage sur le formulaire pour l'extraction.

• Dans la boucle, avant l'instruction ligne.MoveNext, ajouter le code suivant :

position = InStr(1,ligne.Fields("societes_nom").Value, cherche, 1)
If (position > 0) Then
resultat.Value = resultat.Value & Chr(13) & Chr(10) & ligne.Fields("societes_nom")
End If

La fonction VBA InStr retourne la position d'une occurrence recherchée dans une chaîne de texte. Elle requiert quatre arguments. En premier nous désignons à partir de quel caractère commencer la recherche, le premier (1). Nous indiquons ensuite quel est le texte dans lequel rechercher l'occurrence (ligne.Fields("societes_nom").Value). La propriété Fields d'un objet RecordSet permet de spécifier le champ précis de l'enregistrement ("societes_nom"). Associée à sa propriété dérivée Value, elle permet d'atteindre le contenu du champ pour l'enregistrement en cours. En troisième argument, nous spécifions l'occurrence recherchée (cherche), soit le mot clé utilisateur stocké dans la variable. En dernier argument, nous indiquons que la méthode de comparaison est textuelle (1).

Si l'occurrence est trouvée, la position retournée par la fonction InStr doit être positive (If (position > 0) Then). Auquel cas nous restituons cette information dans la zone de texte resultat, en la concaténant à la potentielle précédente information trouvée (resultat.Value = resultat.Value &). Pour que chaque résultat trouvé soit placé sur une nouvelle ligne, nous simulons des retours chariots et sauts de paragraphes grâce à la fonction Chr en lui passant les bons codes de caractères (& Chr(13) & Chr(10) &). Puis nous associons le résultat concordant (ligne.Fields("societes_nom")).

Le traitement de la boucle est terminé. Il est très important de libérer les ressources. Toute connexion ouverte doit être fermée lorsqu'elle n'est plus utilisée.

• Après la boucle, avant le End Sub, ajouter les instructions suivantes :

ligne.Close
base.Close
Set ligne = Nothing
Set base = Nothing

Nous fermons la connexion grâce à la méthode Close des objets Recordset et Database. Puis nous les vidons grâce à une nouvelle affection et au mot clé Nothing, afin de libérer la mémoire.

• Enregistrer les modifications (CTRL + S),
• Basculer sur l'application Access (ALT + F11),
• Double cliquer sur le formulaire Formulaire_connexion pour l'exécuter,
• Taper le mot clé domaine par exemple et cliquer sur le bouton Rechercher,

Le code livre les résultats de la recherche dans la zone d'extraction comme l'illustre la capture ci-dessus. Dans cet exemple, nous avons ajouté un compteur qui s'incrémente dans la boucle, afin d'afficher le nombre de résultats concordants. Le code complet de ce programme Visual Basic Access pour extraire l'information de base de données est le suivant :

Private Sub chercher_Click()
Dim ligne As Recordset: Dim base As Database
Dim cherche As String: Dim position As Integer: Dim compteur As Integer

If (IsNull(mot_cle.Value)) Then Exit Sub

cherche = mot_cle.Value
resultat.Value = "": compteur = 0

Set base = Application.CurrentDb
Set ligne = base.OpenRecordset("societes", dbOpenTable, dbReadOnly)

If ligne.RecordCount = 0 Then Exit Sub
ligne.MoveFirst

Do
position = InStr(1, ligne.Fields("societes_nom").Value, cherche, 1)
If (position > 0) Then
resultat.Value = resultat.Value & Chr(13) & Chr(10) & ligne.Fields("societes_nom")
compteur = compteur + 1
End If

ligne.MoveNext
Loop Until ligne.EOF = True

resultat.Value = compteur & " résultats trouvés." & Chr(13) & Chr(10) & Chr(13) & Chr(10) & resultat.Value

ligne.Close
base.Close
Set ligne = Nothing
Set base = Nothing
End Sub

Requête d'extraction d'information en Visual Basic Access
Dans l'exemple précédent, nous avons réussi à extraire l'information de base de données, en parcourant les enregistrements d'une table. Mais, d'une part nous avons codé la recherche de correspondance nous-même et d'autre part, nous n'avons réalisé l'extraction que sur un seul champ. Dans l'exemple qui suit, nous allons améliorer la recherche. Tout d'abord nous constaterons que VBA Access propose des propriétés et méthodes dédiées pour optimiser le code et retourner des résultats de recherche plus fins. Ensuite, nous verrons qu'il est possible de réaliser des recherches précises en imbriquant des instructions SQL dans les expressions. Nous allons réviser le code précédent.

• Supprimer les déclarations des deux variables cherche et position,
• Dans la partie déclarative, ajouter la déclaration des trois variables suivantes :

Dim retour As String: Dim expression As String: Dim compteur As Integer

La variable retour sera utilisée pour mémoriser les informations qui correspondent à la recherche, afin de les afficher dans la zone d'extraction. La variable expression permettra de stocker l'instruction Sql à passer en paramètre d'une méthode DAO afin de faciliter la recherche d'information. Enfin la variable compteur sera incrémentée à chaque fois qu'un résultat concorde pour proposer à l'issue, le nombre de résultats trouvés et extraits.

• Après le test sur le contenu de la zone de saisie : If (IsNull(mot_cle.Value)) Then Exit Sub, ajouter la ligne de code suivante :

expression = "societes_nom LIKE '*" & mot_cle.Value & "*'"

Il s'agit d'un bout d'instruction SQL. Le critère est posé sur le champ societes_nom de la table. Il s'agit de trouver tous les enregistrements pour lesquels ce champ contient le mot clé tapé par l'utilisateur (LIKE '*" & mot_cle.Value & "*'"). Le mot clé LIKE signifie Comme, il ne désigne pas une correspondance exacte. Comme nous encadrons le mot clé d'étoiles (*), l'instruction signifie : qui contient ce mot clé.

Qui dit syntaxe SQL, dit possibilités plus étendues. Donc nous allons en profiter pour recouper ce critère avec celui sur le département, si ce choix est émis par l'utilisateur au travers de la liste déroulante. Donc nous devons commencer par réaliser un test sur la liste déroulante.

• A la suite de l'affectation de la variable expression précédente, ajouter le code suivant :

If (IsNull(liste_deroulante) = False) Then
expression = expression & " AND societes_departement='" & liste_deroulante.Value & "'"
End If

La fonction VBA IsNull permet de nouveau de réaliser un test booléen sur un contrôle de formulaire, la liste déroulante, afin de savoir si celle-ci contient une valeur ou non. Si le test est concluant, signifiant que la liste déroulante retourne une valeur, nous recoupons le critère de l'expression SQL avec une condition sur le champ societes_departement de la table. C'est le mot clé AND en SQL qui permet de recouper les critères. Le champ societes_departement pour l'enregistrement en cours de lecture, doit retourner la valeur exacte définie par la liste (societes_departement='" & liste_ deroulante .Value & "'"). La liste est conçue sur une extraction de la table, il n'y a donc pas d'ambiguïté possible.

• Dans les affectations de variables qui suivent, supprimer la ligne : cherche = mot_cle.Value,
• En revanche, après resultat.Value = "", ajouter l'affectation : compteur = 0,
• Modifier l'affectation de la variable ligne, comme suit :

Set ligne = base.OpenRecordset("societes", dbOpenDynaset)

La constante dbOpenDynaset remplace dbOpenTable. Il s'agit d'un type d'ouverture constitué de pointeurs dédiés à la recherche par correspondance, avec les méthodes d'un objet Recordset.

• Après l'affectation des variables objets ligne et base, supprimer les deux lignes suivantes :

If ligne.RecordCount = 0 Then Exit Sub
ligne.MoveFirst

En effet, nous allons utiliser les méthodes ActiveX Data Object pour parcourir les enregistrements en fonction des recherches qui correspondent.

• A la place, ajouter les instructions suivantes :

ligne.FindFirst expression
If ligne.NoMatch = False Then
retour = ligne.Fields("societes_nom").Value & "-" & ligne.Fields("societes_departement").Value
resultat.Value = resultat.Value & Chr(13) & Chr(10) & retour
compteur = compteur + 1
End If

La méthode FindFirst d'un objet Recordset permet de placer le pointeur de lecture, sur le premier enregistrement qui correspond au critère généré par la syntaxe SQL, mémorisé dans la variable expression, passée en argument. La proprité NoMatch associée renvoie un booléen qui permet de confirmer que le résultat concorde. Alors (Then), nous concaténons les informations des champs societes_nom et societes_departement dans la variable retour, pour livrer une extraction plus fine. Et nous restituons cette information ligne à ligne (Chr(13) & Chr(10)), dans la zone d'extraction (resultat.Value =). Mais la méthode FindFirst permet de ne valider que le premier résultat concordant. Nous devons donc continuer d'exploiter la boucle Do pour déplacer le pointeur de lecture, de résultat concordant en résultat concordant.

• Dans la boucle, entre le Do et le Loop, remplacer tout le code par le suivant :

ligne.FindNext expression
If ligne.NoMatch = False Then
retour = ligne.Fields("societes_nom").Value & "-" & ligne.Fields("societes_departement").Value
resultat.Value = resultat.Value & Chr(13) & Chr(10) & retour
compteur = compteur + 1
Else
ligne.MoveNext
End If

A l'instar de la méthode FindFirst, la méthode FindNext d'un objet Recordset permet de placer le pointeur de lecture, sur l'enregistrement suivant concordant. Comme précédemment, si la correspondance est confirmée, nous concaténons les résultats que nous affichons dans la zone d'extraction. Dans le cas contraire (Else), nous forçons le déplacement du pointeur de lecture sur l'enregistrement suivant, pour poursuivre le déroulement de la boucle et ne pas rester bloqués. Le code de la boucle est terminé.

• Après la boucle, ajouter les lignes suivantes, avant la fermeture des objets de connexion :

If (resultat.Value = "") Then
resultat.Value = "Aucun résultat trouvé"
Else
resultat.Value = compteur & " résultats trouvés." & Chr(13) & Chr(10) & Chr(13) & Chr(10) & resultat.Value
End If

Il ne reste plus qu'à tester en désignant à la fois un département et un mot clé de recherche sur le nom, depuis le formulaire graphique.

• Enregistrer les modifications,
• Basculer sur l'application Access (Alt + F11),
• Double cliquer sur le formulaire depuis le volet des objets Access pour l'exécuter,
• Choisir un département avec la liste déroulante, par exemple le 07,
• Puis taper un mot clé, par exemple : Domaine et cliquer sur le bouton Rechercher,

Comme l'illustre la capture ci-dessous, l'extraction est instantanée et répond aux deux critères recoupés. Ce sont les méthodes FindFirst et FindNext de l'objet Recordset qui permettent de pointer directement sur les enregistrements concordant avec l'instruction SQL passée en paramètre. La propriété Fields de ce même objet Recordset a permis d'extraire l'information de champ souhaitée et de la recomposer dans la zone d'extraction. Vous notez de même l'information de synthèse, consolidée en tête de l'extraction sur le nombre de résultats concordants, grâce à la variable compteur, incrémentée à chaque résultat trouvé.


Nous pourrions encore simplifier le code en connectant directement l'objet Recordset, au résultat de l'extraction d'une requête dynamique SQL dont les critères seraient basés sur la valeur des contrôles du formulaire. Le code s'en trouverait simplifié. En voici un exemple fonctionnel :

Dim ligne As Recordset: Dim base As Database: Dim retour As String: Dim compteur As Integer

On Error GoTo erreur:

resultat.Value = ""

Set base = Application.CurrentDb
Set ligne = base.OpenRecordset("SELECT * FROM societes WHERE societes_nom Like '*" & [Forms]![Formulaire_connexion]![mot_cle] & "*' AND societes_departement='" & liste_deroulante.Value & "'", dbOpenDynaset)

ligne.MoveFirst

While Not ligne.EOF
resultat.Value = resultat.Value & Chr(13) & Chr(10) & ligne.Fields("societes_nom").Value
compteur = compteur + 1
ligne.MoveNext
Wend

If (resultat.Value = "") Then
resultat.Value = "Aucun résultat trouvé"
Else
resultat.Value = compteur & " résultats trouvés." & Chr(13) & Chr(10) & Chr(13) & Chr(10) & resultat.Value
End If

ligne.Close
base.Close
Set ligne = Nothing
Set base = Nothing

Exit Sub

erreur:
resultat.Value = "Aucun résultat trouvé"

Une gestion d'erreur (On Error GoTo erreur:) est prévue dans ce code pour anticiper le plantage dans le cas où la requête attaquée ne retourne aucun résultat. Dans ce cas, le code est renvoyé à l'étiquette erreur en fin de code, pour afficher le message à l'utilisateur.