La plus simple d'utilisation est sans nul doute la commande Rechercher du menu Édition/Rechercher que l'on peut appeler via l'icône Jumelles de la barre d'icônes Base de données ou encore grâce à Ctrl+F.

Celle-ci effectue des recherches séquentielles à partir d'un critère unique. En d'autres termes, elle va parcourir un ensemble d'enregistrements (table ou requête) et s'arrêter sur le prochain enregistrement satisfaisant au critère.

Le filtre accessible par le menu Enregistrement/Filtre permet de visualiser un groupe d'enregistrements suivant un ou plusieurs critères, un peu à la manière d'une requête. L'interface ressemble au QBE.

On peut également utiliser les boutons ci-dessous pour faire et défaire des filtres. Ce sont d'ailleurs mes préférés, car leur utilisation est simple et intuitive.

_{QBE : littéralement Query By Example, désigne l'utilitaire de construction des requêtes de l'interface ACCESS.}

La requête, comme le filtre, permet de visualiser un groupe d'enregistrements d'après un critère.

Dans le cas d'une application fonctionnant avec un runtime, il est impossible de construire une requête à l'aide du QBE, de même qu'un utilisateur lambda n'a pas souvent la capacité ou l'envie de l'utiliser.
Ce tutoriel va décrire une solution de substitution totalement générique comme à mon habitude.

Si vous ne souhaitez pas utiliser plusieurs critères de recherche ou que vous n'opérez que sur une seule table, je vous conseille plutôt l'excellente solution de Cafeine à cette adresse.

Le bouton recherche est le moteur de notre formulaire. Il contient le code essentiel au fonctionnement de l'outil puisqu'il permet à l'aide des options préalablement choisies dans le formulaire de créer une chaîne SQL valide et de visualiser son résultat.

    SELECT Table.* FROM Table;

Cette chaîne est ensuite modifiée par l'ajout de la clause WHERE.

    SELECT Table.* FROM Table WHERE Table.champ LIKE "moncritere";

VI-A-1. La syntaxe SQL décryptée▲

Après la théorie nous allons passer à la pratique en traitant uniquement les données de type Texte. Nous traiterons les autres types dans un des chapitres suivants.
Faites un clic droit sur le bouton Rechercher,
choisissez Créer un évènement...,
dans la fenêtre Choisir générateur,
cliquez sur Générateur de code
,
Le module s'ouvre sur l'évènement Btn_Recherche_Click. Entrez le code suivant :

    Dim strTable As String, strField As String, strCriteria As String, strSql As String
    Dim Criter As Variant

    strTable = "[" & Me.cbo_Table & "]"         ' récupère le nom de la table
    strField = "[" & Me.cbo_Champ & "]"         ' récupère le nom du champ

    ' compose le critere de recherche
    strCriteria = strTable & "." & strField & " Like """ & Me.txt_Critere & """"

    ' construit la requête sql
    strSql = "SELECT DISTINCTROW " & strTable & ".*"
    strSql = strSql & " FROM " & strTable
    strSql = strSql & " WHERE ((" & strCriteria & "));"
    

    Me.lst_Resultat.RowSource = strSql  ' affecte sql a lst_Resultat
    Me.lst_Resultat.Requery             ' recalcule la liste

Il est important de remarquer que les 2 dernières lignes de ce code constituent le mécanisme du moteur de recherche.

Même si l'utilisation d'espaces dans les noms de tables et de champs est autorisée dans Microsoft ACCESS, il est fortement déconseillé de le faire. En effet chaque fois qu'un nom comporte au moins un espace il faut l'entourer de crochets []. Dans le QBE (générateur de requête) ces crochets peuvent être insérés automatiquement. Mais le QBE peut interpréter également le nom comme une chaîne de caractères ou au pire provoquer une erreur.
Dans le code VBA, il faut toujours le faire manuellement ce qui ralentit l'écriture du code et peut causer des erreurs.

Notre moteur de recherche est prêt. Pour l'instant il ne fonctionne qu'avec des données de type texte et pour une égalité.
Cette dernière affirmation n'est qu'apparente, le prochain chapitre le démontre.

Choisissez une table et un champ texte et saisissez une valeur incomplète dans le critère.
Pour l'exemple j'ai volontairement choisi une série de mots simples.

La liste des mots

• Eau
• Auto
• Tableau
• Eaux
• Rideaux

Essayez tour à tour l'insertion de l'étoile * avant et après le mot et cliquez sur le bouton de recherche.
Vous obtiendrez les résultats suivants :

L'opérateur LIKE que nous avons employé peut, grâce à quelques caractères jokers substituer un ou plusieurs caractères dans la chaîne recherchée. C'est l'un des opérateurs le plus puissants disponibles dans ACCESS. Il existe dans VBA, SQL et dans les expressions.

Vous pouvez consulter les articles suivants sur le MSDN. Ceux-ci s'appliquent à ACCESS 2000, mais sont toujours d'actualités.
Fundamental MS JET SQL for ACCESS 2000
Intermediate MS JET SQL for ACCESS 2000
Advanced MS JET SQL for ACCESS 2000

Comme vous l'avez constatez la recherche fonctionne, mais seulement avec des champs de type Texte (Texte, Mémo...). Les jokers sont pratiques, mais sont complexes pour un utilisateur.

• Est strictement identique
• Commence par
• Contient
• Finit par
• Ne contient pas

Ces opérateurs sont les plus utilisés, nous pourrions en mettre plusieurs autres comme "ne commence pas par" ou encore "ne finit pas par", mais il faut bien en laisser un peu à votre réflexion.

VII-A-1. Mise en place▲

Pour mettre en oeuvre cette fonctionnalité, nous devons définir un groupe de cases d'options dans notre formulaire.
Celui devrait se présenter comme ceci :

Groupe d'option / choix de l'opérateur
Propriété	Valeur
Nom	opt_Recherche
Valeur par défaut	3

Nom d'étiquette	Valeur
Etre strictement identique	1
Commencer par la valeur	2
Contenir la valeur	3
Finir par la valeur	4
Ne pas contenir la valeur	5

Très important ! Renommez les cases d'options de opt_Ope1 à opt_Ope5 et leur étiquette de lbl_Etiq1 à lbl_Etiq5, car nous y ferons appel ultérieurement.

La valeur par défaut sélectionnée à l'ouverture du formulaire est définie à 1. Cela correspond à Etre strictement identique.
Pour fixer une option différente, vous devez agir sur la propriété Valeur par défaut du groupe d'option.
Entrez la valeur correspondant à la valeur de l'option.

VII-A-2. Le code VBA▲

    ' compose le critere de recherche
    strCriteria = strTable & "." & strField & " Like """ & Me.txt_Critere & """"

           Select Case Me.opt_Recherche
                  Case 1 ' strictement égal
                       strCriteria = strTable & "." & strField & " Like """ & Me.txt_Critere & """"
                  Case 2 ' commence par
                       strCriteria = strTable & "." & strField & " Like """ & Me.txt_Critere & "*"""  
                  Case 3 ' contient
                       strCriteria = strTable & "." & strField & " Like ""*" & Me.txt_Critere & "*"""                               
                  Case 4 ' finit par
                       strCriteria = strTable & "." & strField & " Like ""*" & Me.txt_Critere & """"
                  Case 5 ' ne contient pas
                       strCriteria = "NOT (" & strTable & "." & strField & " Like ""*" & Me.txt_Critere & "*"")"
           End Select

Au cours de ce chapitre, nous allons traiter les 21 types de données existants. Cependant certains n'existent pas dans les tables Jet.
Ceux-ci seront regroupés en 3 catégories.

Les 3 catégories

1. Booléen,
2. Numérique et Date,
3. Texte, Mémo et Hyperlien

Pour chaque groupe les opérateurs, la syntaxe SQL et l'affichage changent.

VII-B-1. Déterminer le type de données▲

Nous allons dans un premier temps déterminer le type de données. Pour cela nous devons interroger les propriétés du champ de la table choisie.

Vous devez d'abord ajouter la référence suivante : Microsoft DAO 3.6 Object Library

Dans la fenêtre Microsoft Visual Basic, utilisez le menu Outils/Références.

VII-B-1-a. Message d'erreur 13▲

Si vous utilisez une librairie ADO (Microsoft ActiveX Data Objects x.x Library) vous devez placer la DAO avant celle-ci dans la liste. Sinon rajoutez systématiquement à vos déclarations de variables DAO le préfixe DAO. Comme dans l'exemple ci-dessous.

Exemple

Sélectionnez

    Dim tbl As DAO.TableDef

Dans le cas contraire, vous serez confronté au message d'erreur suivant :

VII-B-1-b. Le Code▲

Insérez le code suivant dans un objet module que vous nommerez Recherche.

Outre le fait de pouvoir appeler une fonction ou procédure de n'importe quel endroit de votre application, l'intérêt de placer du code dans un module est de pouvoir y faire appel à partir de la fenêtre d'Exécution.

À insérer dans un module

Sélectionnez

Function lf_GetTypeField(lfNameTbl As String, lfNameFld As String)
' Renvoie le numéro du type du champ
'lfNameTbl = nom de la table
'lfNameFld = nom du champ

    Dim dbs As Database             ' Objet de la base
    Dim tbl As TableDef             ' Objet de définition de table

    Set dbs = CurrentDb             ' ouvre la base courante
    Set tbl = dbs.TableDefs(lfNameTbl)  ' ouvre la définition table

    lf_GetTypeField = tbl.Fields(lfNameFld).Type  ' renvoie le type de champ
    
    Set tbl = Nothing                ' libération des objets
    Set dbs = Nothing
    
End Function

Vous pouvez tout de suite tester cette fonction grâce à la fenêtre Exécution présente dans l'interface Microsoft Visual Basic. Tapez Ctrl+G ou encore menu Affichage/Fenêtre Exécution. Lorsque le curseur clignote dans la fenêtre, tapez la syntaxe suivante :

Pour test dans la fenêtre d'exécution

Sélectionnez

? lf_GetTypeField("Matable", "Monchamp")

Attention ! Matable représente le nom d'une table existante, attachée ou non, de votre base de données actuelle et Monchamp le nom d'un champ de cette table. Si l'un ou l'autre contient des espaces ou des caractères spéciaux, vous devez entourer ces noms de crochets.

Validez pour voir apparaître le numéro du type de données. C'est celui-ci que nous allons traiter dans notre code.

VII-B-2. L'affichage▲

Pour que notre formulaire soit interactif, il convient de changer l'affichage des opérateurs suivant le type de données du champ choisi.

Ayant déjà traité le cas de données texte dans un des chapitres précédents nous n'avons plus que 2 cas à traiter qui sont présentés ci-dessous.

Numérique, Date
Egal à =
Supérieur ou égal à >=
Inférieur ou égal à <=
Différent de <>

Booléen (oui/non)
Oui
Non
Rien (Null)

Chaque type de champ peut contenir une valeur nulle. Celle-ci correspond à une absence de saisie. Dans le cas actuel une valeur ni à oui ni à non sera égale à NULL. Attention ! Ce fonctionnement est conditionné par la propriété Valeur par défaut du champ correspondant que vous pouvez définir dans la structure de la table.

Nous pouvons afficher le type de champ au moment du choix. Insérez une étiquette à droite de la zone de liste déroulante cbo_Champs. Utilisez les propriétés ci-dessous.

Etiquette / Affiche le type de champ
Propriété	Valeur
Nom	lbl_TypeChamp
Légende	insérez un espace

Vous pouvez remarquer que si vous ne saisissez pas de contenu elle disparait. Ceci peut être évité grâce à l'insertion d'un espace.

Pour cette partie il s'agit simplement de changer la légende (l'espace) de l'étiquette suivant le type de données. Le meilleur moment pour changer l'affichage sera après le choix du champ. L'évènement Après MAJ de la liste des champs semble tout désigné pour accomplir cette tâche.
Placez-vous sur votre formulaire Recherche
Passez en mode Création.
Cliquez sur le contrôle cbo_champ
Dans les propriétés, placez-vous sur Après MAJ et utilisez l'icône de création d'évènement pour ouvrir la procédure correspondante.
Entrez le code suivant :

À insérer

Sélectionnez

If IsNull(strTable) Or IsNull(strField) Then
   Exit Sub     ' l'un des champs est vide
End If

' initialise les étiquettes de l'opérateur
Me.lbl_Etiq1.Visible = True
Me.lbl_Etiq2.Visible = True
Me.lbl_Etiq3.Visible = True
Me.lbl_Etiq4.Visible = True
Me.lbl_Etiq5.Visible = True
Me.opt_Ope1.Visible = True
Me.opt_Ope2.Visible = True
Me.opt_Ope3.Visible = True
Me.opt_Ope4.Visible = True
Me.opt_Ope5.Visible = True
Me.txt_Critere.Visible = True


Select Case lf_GetTypeField(strTable, strField)  ' pour trouver le type du champ
    
    
    Case Is = dbBoolean     ' Booléen
         Me.lbl_TypeChamp.Caption = "Oui/Non"
         Me.lbl_Etiq1.Caption = "Oui"
         Me.lbl_Etiq2.Caption = "Non"
         Me.lbl_Etiq3.Visible = False    ' cache, car inusité dans ce cas
         Me.lbl_Etiq4.Visible = False    ' idem
         Me.lbl_Etiq5.Visible = False    ' idem
         Me.opt_Ope3.Visible = False
         Me.opt_Ope4.Visible = False
         Me.opt_Ope5.Visible = False
         Me.txt_Critere.Visible = False   ' pas de critère

    Case dbByte To dbBinary, dbLongBinary, dbGUID to dbVarBinary, dbNumeric to dbTimeStamp 
    ' Numériques / date
         Me.lbl_TypeChamp.Caption = "Numérique"
         Me.lbl_Etiq1.Caption = "Etre égale ="
         Me.lbl_Etiq2.Caption = "Etre supérieure >="
         Me.lbl_Etiq3.Caption = "Etre inférieure <="
         Me.lbl_Etiq4.Caption = "Etre différente <>"
         Me.lbl_Etiq5.Visible = False
         Me.opt_Ope5.Visible = False
            
    Case dbText, dbMemo, dbChar ' texte / mémo
         Me.lbl_TypeChamp.Caption = "Texte"
         Me.lbl_Etiq1.Caption = "Etre strictement identique"
         Me.lbl_Etiq2.Caption = "Commencer par la valeur"
         Me.lbl_Etiq3.Caption = "Contenir la valeur"
         Me.lbl_Etiq4.Caption = "Finir par la valeur"
         Me.lbl_Etiq5.Caption = "Pas contenir la valeur"
            
     Case Else
         Me.lbl_TypeChamp.Caption = "Cas non prévu " & lf_GetTypeField(Me.cbo_Table, Me.cbo_Champ)

End Select

Faites un essai. Normalement si vous sélectionnez tour à tour des champs n'ayant pas le même type vous devriez voir apparaître les différentes possibilités.

VII-B-3. Le code VBA▲

Dim intTypChamp As Integer
Dim intOpeChamp As Integer

Select Case Me.opt_Recherche

intTypChamp = lf_GetTypeField(strTable, strField)  ' pour trouver le type du champs ...
intOpeChamp = Me.opt_Recherche

Select Case intTypChamp
            
       Case dbBoolean                       ' bool
            If intOpeChamp = 1 Then          ' oui
               strCriteria = strTable & "." & strField & "=-1"
            ElseIf intOpeChamp = 2 Then      ' non
               strCriteria = strTable & "." & strField & "=0"
            Else
               strCriteria = strTable & "." & strField & "=Null"
            End If
          
       Case dbByte To dbBinary, dbLongBinary, dbBigInt To dbVarBinary, dbNumeric To dbTimeStamp 
       ' traite les numeriques                
            strCriteria = Me.txt_Critere 
            ' traite la virgule si elle existe
            If InStr(1, Me.txt_Critere, ",") > 0 Then strCriteria = Replace(Me.txt_Critere, ",", ".", 1)
            ' pour les versions antérieures à la 2000
            'If InStr(1, Me.txt_critere, ",") > 0 Then _
            ' strCriteria = Left(Me.txt_critere, InStr(1, Me.txt_critere, ",") - 1) _
            ' & "." & Right(Me.txt_critere, InStr(1, Me.txt_critere, ","))
                     
            If intTypChamp = dbDate And IsDate(Me.txt_Critere) Then  strCriteria = "#" _
               & Me.txt_Critere & "#"                  ' type champ = date
            ' rajoute les dièses
                      
            If Not IsNull(Me.txt_Critere) Then
               Select Case intOpeChamp                    ' numerique, date
                   Case 1 ' =
                        strCriteria = strTable & "." & strField & "=" & strCriteria
                                
                   Case 2 ' >=
                        strCriteria = strTable & "." & strField & ">=" & strCriteria
                                
                   Case 3 ' <=
                        strCriteria = strTable & "." & strField & "<=" & strCriteria
                                
                   Case 4 '<>
                        strCriteria = strTable & "." & strField & "<>" & strCriteria
               End Select
            End If
           
       Case dbText, dbMemo, dbChar                      ' texte
            Select Case intOpeChamp

                  Case 5 ' ne contient pas
                       strCriteria = "NOT (" & strTable & "." & strField & " Like ""*" & strCriteria & "*"")"
           End Select

       Case Else
            MsgBox "Cas non prévu."
            Exit Sub
   End Select

Ce chapitre tant attendu traite de la recherche multicritère par imbrication ou tout simplement comment faire une recherche dans le résultat de la recherche précédente.
Pour cela nous avons simplement besoin d'une case d'option indépendante et d'un peu de code.

Insérez une case d'option indépendante.

Maintenant que le contrôle est en place nous pouvons passer au code. Celui-ci n'est pas lié à ce contrôle, mais au bouton de recherche.

VIII-A-1. Le code VBA▲

    ' construit la requête sql
    strsql = "SELECT DISTINCTROW " & strTable & ".*"
    strsql = strsql & " FROM " & strTable
    strsql = strsql & " WHERE ((" & strCriteria & "));"

If Me.Opt_RechCourante And Not Len(Me.Lst_Resultat.RowSource) = 0 Then 
   If Not Me.Lst_Resultat.RowSource Like "*FROM " & strTable & "*" Then   
      MsgBox "La recherche précédente ne porte pas sur la même table que la recherche actuelle.", _ 
             vbExclamation + vbOKOnly, "Erreur"
      Exit Sub
   End If
   strsql = Left(Me.Lst_Resultat.RowSource, Len(Me.Lst_Resultat.RowSource) - 3)
   strsql = strsql & " AND " & strCriteria & "));"
Else
   ' construit la rq sql
   strsql = "SELECT DISTINCTROW " & strTable & ".*"
   strsql = strsql + " FROM " & strTable
   strsql = strsql + " WHERE ((" & strCriteria & "));"
End If

Pour composer la liste des tables automatiquement nous devons créer une table de réception des informations. Cette table sera renseignée au lancement du formulaire et son contenu s'affichera dans la zone liste cbo_table.

Ouvrez le module Recherche qui doit déjà contenir la fonction lf_GetTypeField() à la suite insérez-y le code suivant.

Function lf_GetTableList()
' renseigne la table tbl_TemplstTbl

Dim qrs As TableDefs
Dim rst As Recordset

Dim strSql As String
Dim i As Integer, j As Integer

' efface la table temporaire
DoCmd.SetWarnings False
strSql = "Delete tbl_TempLstTbl.*"
strSql = strSql + " FROM tbl_TempLstTbl;"
DoCmd.RunSQL strSql

' rempli    la table temporaire
Set qrs = CurrentDb.TableDefs
Set rst = CurrentDb.OpenRecordset("tbl_TempLstTbl")

For i = 0 To qrs.Count - 1
    ' écarte les tables temp et système
    If Not (qrs(i).Name Like "*Temp*") And Not (qrs(i).Name Like "Msys*") And _
       Not (qrs(i).Name Like "*tmp*") Then
       rst.AddNew
       rst.Fields(0) = qrs(i).Name
       rst.Update
    End If
Next
lf_GetTableList = rst.RecordCount

rst.Close
Set rst = Nothing
Set qrs = Nothing
DoCmd.SetWarnings True
End Function

C'est le code qui va réaliser l'inventaire de tous les noms de tables de votre base, attachées ou non, à l'exclusion des tables systèmes (Msys), des tables Temporaires (Temp) et autres objets temporaires cachés (~tmp).
Vous pouvez constater que la table de réception (tbl_TempLstTbl) est vidée à chaque exécution et que la fonction renvoie le nombre de tables enregistrées dans la table (rst.recordcount) vous comprendrez pourquoi dans le prochain chapitre.

Après ce que nous avons vu au cours de ce tutoriel, l'intégration de cette fonctionnalité n'a rien de complexe.
Affichez les propriétés du formulaire, dans la propriété Sur ouverture. Insérez le code suivant.

' crée la liste des tables
If lf_GetTableList() = 0 Then
   MsgBox "Pas de tables dans cette application .", vbInformation + vbOKOnly, "Erreur"
   Cancel = True
End If

Réglez maintenant les propriétés de cbo_table suivant le tableau ci-dessous. Dans le chapitre précédent, nous avons pu observer que la fonction renvoyait le nombre de tables inscrites. Cela nous permet de vérifier rapidement que l'on ne lance pas le formulaire pour rien.

Sauvez le formulaire et le module puis rouvrez-le.
Allez dans la liste des tables pour constater que l'ensemble des tables de votre base de données y figurent.
Voici à quoi devrait ressembler votre formulaire une fois en fonctionnement.