FICHES METHODES ACCESS -...

FICHES METHODES

ACCESS

Novembre 2002

Auteur : J. Steffe Enita de Bordeaux

SOMMAIRE

Création d’une table_________________________________________________________ 1

Présentation des formulaires __________________________________________________ 4

Principales étapes pour créer un formulaire______________________________________ 6

Sous-formulaire : comment saisir simultanément des enregistrements dans 2 tables liées._ 8

Principales étapes pour créer une liste modifiable ________________________________ 12

Créer une liste de recherche d’un enregistrement en en-tête de formulaire ____________ 14

Actualiser une liste après ajout d’un enregistrement ______________________________ 16

Actualiser une liste dans un sous-formulaire en Access 2000 _______________________ 20

Masques de saisie __________________________________________________________ 21

Test de cohérence d’un enregistrement avant son ajout/modification_________________ 22

Tester la cohérence des enregistrements et appliquer la mise a jour et la suppression en cascade __________________________________________________________________ 23

Comment définir le contenu d’une liste depuis une autre liste ? _____________________ 27

Principales étapes pour créer une requête a l’aide du module graphique d’Access . _____ 28

Les 3 types de jointure pour une requête________________________________________ 30

Principales étapes pour créer un état __________________________________________ 32

Formulaires de paramétrage pour ouvrir un état sous certaines conditions____________ 33

Eviter d’ouvrir un état sans enregistrement _____________________________________ 35

Afficher les critères de sélection sur l’état ______________________________________ 36

Comment créer une macro___________________________________________________ 38

Compacter une base de données ______________________________________________ 39

Séparation des données et des traitements : tables attachées et lien odbc ______________ 40

Auteur : J. Steffe Enita de Bordeaux

CREATION D’UNE TABLE 1 - Qu’est-ce qu’une table ? Une table est un ensemble d'informations homogènes. Elle se présente sous forme de tableau où chaque colonne correspond à un champ et chaque ligne à un enregistrement. Un (ou plusieurs) champ sert à identifier et à retrouver rapidement chaque enregistrement, c'est la clé primaire. Access n'accepte pas deux enregistrements différents ayant la même valeur de clé primaire (doublon), le choix de la clé est donc très important – il est dicté par le modèle. 2 - Création de la table Dans la fenêtre Base de données choisir l'onglet table puis le bouton Nouveau... Vous avez le choix entre poursuivre avec l'aide de l'assistant ou créer manuellement la table. Plaçons nous dans ce dernier cas. 3 - Les champs Pour définir un champ il faut préciser son nom, son type, sa description et ses propriétés.

• Nom de champ Les noms des champs doivent être suffisamment clairs pour identifier les données, il est cependant conseillé de définir des noms brefs, faciles à mémoriser et à taper (éviter, si possible, le caractère espace).

• Type de champ (Voir fiche d’aide en ligne « Choix du type de données d’un champ »,...)

Texte Caractère (<250) Numérique Nombres entiers ou décimaux Date / heure Dates / heures Monétaire Valeurs monétaires Compteur Incrément automatique à chaque nouvel enregistrement Ou i/ Non Valeur booléenne Mémo Caractère (<64000) Liaison OLE Objets OLE, graphiques

• Description des champs Pour faciliter la maintenance de la table on peut décrire chaque champ.

Auteur : J. Steffe Enita de Bordeaux 1

4 - Propriétés des champs (variables selon le type de données) :

• Taille

Limite la taille d'un champ texte ou la fourchette de valeurs d'un champ numérique.

• Format

(Voir fiche d’aide en ligne « Propriété format »,...) Permet d'afficher l'information selon la présentation choisie (majuscule, dates en chiffres ou en lettres,..)

• Masque de saisie

(Voir fiche d’aide en ligne « Propriété masque de saisie »,...) Contrôle intervenant au moment de la saisie, il peut être créé avec l'aide du générateur de masque de saisie.

• Décimales

Nombres de chiffres après la virgule, pour champs numériques et monétaires.

• Légende

Texte remplaçant le nom du champ dans les formulaires ou les états.

• Valeur par défaut

Valeur qui apparaît automatiquement dans le champ à chaque nouvel enregistrement, cette valeur peut être modifiée lors de la saisie.

• Valide si Condition qui doit être satisfaite pour qu'Access accepte la valeur saisie dans le champ.

• Message si erreur Message qui s'affiche si la propriété Valide si, n'est pas satisfaite.

• Null interdit Si la propriété est Oui, la saisie de ce champ est obligatoire.

• Chaîne vide autorisée « » (Voir fiche d’aide en ligne « Propriété chaîne vide autorisée »,...) Si la propriété est Oui, on peut saisir des guillemets doubles et ainsi faire la différence entre information non connue et information absente.


• Indexé L’utilisation d’un index accélère les opérations de consultation, mais ralentit celles de mises à jour car il y a création de l’index.

5 - Clé primaire (Voir fiche d’aide en ligne « Clés primaires »,...) Lorsque la liste des champs est terminée ne pas oublier de définir la clé primaire :

- cliquer sur le premier champ de la clé puis éventuellement sur les autres avec la touche Ctrl enfoncée, - cliquer sur le bouton « clé » ( ) ou choisir les commandes Edition puis Clé primaire.

Attention, Si vous n'avez pas créé de clé primaire le système peut en créer une, de type compteur, lors de la sauvegarde de la table. 6 - Sauvegarde, nom de table Le nom de la table est donné lors du premier enregistrement à l'aide des commandes Fichier puis Enregistrer ou Fichier puis Enregistrer sous. 7 - Modification de la structure Pour modifier la structure d'une table, dans la fenêtre Base de données choisir l'onglet «table» puis le bouton «Modifier». Tous les objets associés à la table doivent être fermés. Attention : avant toute modification de structure de la table, mesurez les conséquences sur les données existantes.


Présentation des formulaires 1 - Qu'est-ce qu'un formulaire?

1) Formulaire dépendant Un formulaire dépendant permet de saisir, modifier, enregistrer les informations d’une table de la base de données. Dans une application, on crée donc autant de formulaires dépendants qu’il y a de tables dans la base. Exemple de formulaire dépendant :

2) Formulaire indépendant

Si le formulaire ne sert pas à saisir les données dans une table, il est alors indépendant. En général, on trouve 2 types de formulaires indépendants :

- les formulaires de menu - les formulaires de paramétrage

Exemple de formulaire de menu :


Exemple de formulaire de paramétrage :

2 - Modes de visualisation pour les formulaires dépendants Il existe 3 modes d’affichage pour créer, modifier, ou supprimer un enregistrement :

• Le mode « simple » : le formulaire n’affiche qu’un enregistrement à la fois • Le mode « continu » : le formulaire affiche les enregistrements de la table en continu

• Le mode « feuille de données » : le formulaire affiche les enregistrements de la table

sous forme de tableau.


Principales étapes pour créer un formulaire 1 – Règles de base Dans une application, il y a autant de formulaires dépendants que de tables. On crée généralement des formulaires indépendants :

• pour gérer des menus, • pour filtrer les informations affichées par un état (formulaire de paramétrage)

Des sous formulaires peuvent être utilisés dans le cas d’une relation 1 (formulaire père) à plusieurs (formulaire fils). Les 2 formulaires doivent avoir une clé commune. 2 - Spécifier le type de formulaire Le formulaire sert-il à saisir/modifier/supprimer les enregistrements d’une table ?

• Si oui, il faut : o créer un formulaire dépendant o spécifier le nom de la table liée dans la propriété « source » du formulaire.

• Sinon : il faut créer un formulaire indépendant (propriété « source » vide) 3 - Choisir le mode d’affichage du formulaire

• Simple • continu • feuille de données.

Cf. « fiche présentation formulaire » 4 - Spécifier les principales propriétés Ex : « Affichage par défaut », « Afficher sélecteur », « Boutons de déplacement » … 5 - Choisir la structure du formulaire Choix de la gestion des sections : que met-on en en-tête de page, en pied-de-page, dans la section détail … NB : ce qui est placé dans la section détail se répétera pour chaque enregistrement de la table liée. 6 - Placer les contrôles (exemples de contrôles : liste, zone de texte, case à cocher …) On placera dans la zone détail du formulaire autant de contrôles qu’il y a de champs dans la table liée. Les contrôles qui font le lien avec un champ de la table sont dits « dépendants ». Pour chaque contrôle, on définira :

• la propriété « source contrôle » : le nom du champ de la table à saisir • le type de contrôle approprié (en fonction du champ lié) :

o case à cocher pour les champs oui/non o zone de texte pour les champs en format texte


o liste de choix pour une clé étrangère Points à vérifier : 1) à chaque champ de la table liée doit correspondre un contrôle dépendant. Il n’existe que 2 exceptions :

- le numéro automatique si son affichage n’est pas utile à l’utilisateur - la clé étrangère dans le cas d’un sous formulaire (elle est renseignée

automatiquement par Access). 2) on ne pourra mettre une liste de choix que pour les champs qui sont une clé étrangère. 7 - Nommer les contrôles Suivre une logique. Exemple , usage de l’ENITA : Zone de texte « nom » = zt_nom Liste modifiable « service » = lm_service 8 - Spécifier les propriétés annexes des contrôles Propriétés de format : « couleur texte », « Police », « Taille caractère » … Ordre d’enchaînement des contrôles sur appui de la touche TAB : propriété « Index tabulation » 9 - Choisir quels seront les événements sur lesquels des actions particulières seront déclenchées On peut intercepter à ce niveau

• les événements associés au formulaire ( Ex : « Sur activation », « Sur fermeture » …) • ou à un contrôle particulier (ex : « Sur réception Focus », « Après MAJ » …).

10 - Programmer le code ou la macro correspondant et l’affecter à l’événement voulu 11 - Mise en forme du formulaire

• Couleur, taille …


Sous-formulaire : comment saisir simultanément des enregistrements dans 2 tables liées.

1 - UTILISATION D’UN SOUS-FORMULAIRE On utilise les sous-formulaires quand on veut afficher/saisir les données qui proviennent de 2 tables différentes (mais qui ont un champ en commun) sur le même écran de saisie. Si on prend le modèle suivant :

CommandesN_commandeDate_commandeN_vendeurNo_clientPayéeLivrée

Lignes_commandes

No_ligneN_commandeRef_produitQuantite

Il est possible de saisir sur le même écran de saisie les commandes et les enregistrements du détail de la commande. Il faudra pour cela créer 2 formulaires (1 formulaire par table) et insérer au sein du formulaire « commandes » le formulaire « détail_commande » (qui deviendra alors sous-formulaire). Ce qui donne par exemple :

Le formulaire père (ex : commande) et le sous-formulaire (ex : détail_commande) sont liés par Access de sorte que le sous-formulaire n’affiche que les enregistrements en rapport avec celui affiché sur le formulaire père.


Dans l’exemple : en plaçant le formulaire détails_commande dans le formulaire commande, Access n’affiche que les lignes de commande correspondant à la commande en cours. 2 - CONDITIONS D’UTILISATION D’UN SOUS-FORMULAIRE Pour créer un sous-formulaire, il faut absolument que les conditions suivantes soient remplies :

- les 2 tables liées aux 2 formulaires doivent avoir un champ commun (dans l’exemple : N_commande). Ce champ est défini en tant que clé primaire dans une table et en clé étrangère dans l’autre table.

- les enregistrements de la table qui contient la clé primaire seront toujours affichés dans le formulaire père.

- les enregistrements de la table qui contient la clé étrangère seront toujours affichés dans le formulaire fils.

- autrement formulé, il faut qu’on ait toujours les cardinalités suivantes : o à un enregistrement du formulaire père correspondra de 0 à n enregistrements

dans le formulaire fils o à un enregistrement du formulaire fils correspondra 1 et 1 seul enregistrement

dans le formulaire père Formulaire père

Formulaire fils

1

n 1

1

Ensuite, il faut bien sûr s’assurer que le mode de saisie retenu soit cohérent pour l’utilisateur. 3 – COMMENT INTERPRETER UN MCD POUR CREER DES SOUS-FORMULAIRES La lecture du MCD permet de repérer automatiquement les possibilités de création de sous formulaire. On distinguera en effet les cas suivants : 1°) Association avec 2 cardinalités maxi = n NB : on s’intéresse ici uniquement aux cardinalités maximum. On aura donc le même résultat avec une association qui a des cardinalités 1,n 1,n ou 0,n 1,n.


0 ,n 0 ,nE n ti te _ A E NT IT E _ B

A sso ci a ti o n _ C

La table générée par l’association pourra être placée en sous-formulaire dans Entité_A ou en sous-formulaire dans Entité_B.

1ère solution 2ème solution

Table A

Table C

Table B

Table A Table B

Table C

2°) Association avec 1 cardinalité maxi = 1,n ou 0,n et 1 autre cardinalité 1,1 Exemple :

0 ,n 1 ,1E n ti te _ A E NT IT E _ B

A sso ci a ti o n _ C

Dans ce cas, on peut créer la structure de formulaire suivante :

Table A

Table B

NB : dans le cas suivant, on ne créera pas de sous-formulaire car un enregistrement de la table B ne sera pas nécessairement relié à un enregistrement de la table A (cf cardinalité minimale 0). Il faut donc pouvoir le saisir de façon indépendante.=> on créera donc un formulaire principal pour la table B.

0,n 0,1

Entite_A Entite_BAssociation_C

4 – CREATION ET MISE EN PLACE D’UN FORMULAIRE AVEC SOUS-FORMULAIRE 1°) il faut créer 2 formulaires (1 pour chaque table) de façon indépendante (cf. fiche création de formulaire). 2°) on insère dans le formulaire père le formulaire qui va devenir sous-formulaire (par un glisser-déplacer)


3°) On indique comment se fait la liaison entre les 2 formulaires à l’aide des 2 propriétés suivantes :

- champ père : nom de la clé primaire - champ fils : nom de la clé étrangère - NB : en général, la clé primaire et la clé étrangère portent le même nom (dans

l’exemple : N_commande). En général, le sous-formulaire est créé en mode feuille de données ou continu. Enfin, il est possible de placer plusieurs sous-formulaires dans le même formulaire ou créer plusieurs niveaux de sous-formulaires (1 formulaire qui contient un sous-formulaire qui contient lui-même un sous-sous-formulaire). Si cela ne pose pas de difficulté technique, cela nécessite en revanche une lourdeur au niveau de l’ergonomie. Il ne faut donc point en abuser.


Principales étapes pour créer une liste modifiable

A quoi sert une liste modifiable ? Une zone de liste modifiable permet à l’utilisateur de sélectionner une information. L’information choisie peut, ensuite être stockée dans un champ d’une table (contrôle dépendant) ou directement utilisée sans être stockée (contrôle indépendant). Exemple de liste dépendante : une liste qui permet de choisir le nom de la commune pour remplir le champ « ville » d’une table. Nb : dans une liste on peut afficher plusieurs lignes qui contiennent chacune plusieurs colonnes. (Ex de liste avec 3 colonnes : code_ville, nom_ville, nb_habitants). Cependant, seule 1 information (1 seule colonne) est gérée par la liste : les autres ne sont présentes qu’à titre d’affichage. Il est de plus possible de cacher la colonne qui contient l’information gérée : fréquemment, on stocke l’information « code » (non affichée dans la liste) et on affiche l’information « libellé » qui est plus claire pour l’utilisateur. Quand utiliser une liste modifiable ?

- pour accélérer la rapidité de saisie. - pour normaliser la saisie (on force l’utilisateur à choisir parmi les données

proposées). - Pour assurer la cohérence de la BDD. Tout champ lié à une clé étrangère

peut donner lieu à une saisie au travers d’une liste. Méthode à suivre 1 - Mettre en place le contrôle de type zone de liste modifiable. Utiliser la boite à outils, assistant contrôle inactif, choisir le bouton « zone de liste modifiable ». 2 – Choisir si l’information sélectionnée dans la liste alimente le champ de la table liée au formulaire Propriété : Source contrôle

Si la liste est dépendante, indiquer le nom du champ de la table associée que vous voulez remplir. Si la liste est indépendante la propriété reste vide.

3 - Construire la liste des informations affichées ou cachées que l’utilisateur sélectionnera 1) Choisir où prendre les informations à afficher : propriété « Origine source »

Il y a 2 possibilités pour remplir une liste : 1- renseigner directement au niveau des propriétés la liste des valeurs en

« dur » (choisir dans ce cas « liste valeurs ») 2- renvoyer dans la liste le résultat d’un requête (choisir dans ce cas « table

/ requête »)


2) Remplir la liste : propriété «Contenu » - Si les données proviennent d’une table ou d’une requête, on a deux possibilités :

. indiquer le nom de la table ou de la requête, la liste affichera les premières colonnes à partir de la gauche de la table ou de la requête, . indiquer une commande SQL du type « SELECT ch1,ch2,ch3.. FROM table1,table2.. WHERE condition1 AND/OR condition2 ........ », utiliser le générateur d’expression pour composer cette commande.

- Si les données proviennent d’une liste de valeurs, indiquer la liste de valeurs séparées par des points virgules.

3) Choisir le nombre de colonnes affichées et cachées : propriété « Nombre colonnes »

Indiquer le nombre total de colonnes affichées et cachées. 4) Propriété : Largeurs colonnes Une colonne sera cachée si sa largeur est nulle, l’information qu’elle contient pourra cependant être stockée dans une table ou utilisée directement. Indiquer en cm les largeurs des colonnes en les séparant par des points virgules. 4 - Choisir l’information affichée par la liste, après sélection. Après sélection, la liste affiche toujours l’information contenue dans la première colonne, à partir de la gauche, dont la largeur est non nulle. 5 – Choisir l’information à retenir et à utiliser. Après sélection, le contrôle liste contient une et une seule information qui correspond à l’information située dans la colonne liée. Toutes les autres informations ne son pas gardées en mémoire. Propriété : Colonne liée

Indiquer le numéro de la colonne qui sera retenue après sélection

Résumé : une liste contient 3 éléments distincts : 1°) le contenu affiché dans la liste (propriété contenu) 2°) la valeur qui sera gérée par la liste (propriété colonne liée). Une seule valeur est gérée, les autres ne sont présentes qu’à l’affichage. 3°) le champ lié de la table (propriété « source contrôle ») L’erreur la plus fréquemment commise est d’oublier de renseigner la propriété « source contrôle » dans le cas d’une liste dépendante.


Créer une liste de recherche d’un enregistrement en en-tête de formulaire

Par défaut, les enregistrements sont stockés dans la table selon l’ordre de saisie. Quand on a rentré beaucoup de données, il devient par conséquent nécessaire de pouvoir atteindre un enregistrement donné très rapidement pour pouvoir le modifier. Au lieu d’utiliser les boutons de déplacement, il faut alors créer une liste qui permette d’atteindre directement l’enregistrement choisi. Exemple :

zt_no

lm_cde

METHODE 1°) Afficher l’en-tête du formulaire (menu « affichage en-tête/pied de formulaire ») 2°) Créer une liste indépendante (on ne spécifiera rien dans la propriété « source contrôle »). La liste ne remplit en effet aucun champ de la table. 3°) Donner un nom à la liste (lm_ …) 4°) paramétrer le contenu de la liste en mettant en colonne liée le champ qui servira à la recherche (en général la clé primaire : ici , no_cde). 5°) sur l’événement « Après Mise à Jour » de la liste, associer la macro suivante :

Action Arguments de l’action Valeur à écrire Atteindre contrôle

Nom_contrôle Nom du contrôle qui contient la clé primaire (ici, zt_no)

Trouver enregistrement Rechercher =nom_liste (ici =[lm_cde]) L’action « trouver enregistrement » permet d’atteindre l’enregistrement dont le contrôle en cours a la même valeur que celle précisée dans l’argument « rechercher ». Il est donc nécessaire, avant d’effectuer un l’action « trouver enregistrement », de placer le curseur sur le contrôle voulu (ici la zone de texte zt_no).


Attention : si vous oubliez le signe « = » dans l’argument rechercher, la macro ne fonctionnera pas.


Actualiser une liste après ajout d’un enregistrement

Sur un formulaire, le contenu de chacune des listes est chargé par Access à l’ouverture du formulaire. Ainsi, si le contenu d’une liste évolue pendant que le formulaire reste ouvert (exemple : on ajoute ou supprime un enregistrement à la table lue par la liste), il n’est pas rafraîchi automatiquement. Par défaut, l’utilisateur ne peut pas voir les dernières mises à jour de données sans fermer et rouvrir le formulaire. Exemple :

Je suis sur le formulaire qui permet de saisir des individus (table individu). La liste « organisme employeur » permet de saisir le champ code_organisme de la table individu et affiche le contenu de la table « organismes » (code_organisme, libellé organisme). Le bouton « nouvel organisme » permet d’ajouter un organisme qui n’existe pas encore. Sur clic de ce bouton, le formulaire organisme s’ouvre et l’utilisateur peut ajouter un nouvel enregistrement. Problème : de retour sur le formulaire individu, l’organisme qui vient d’être entré n’apparaît pas car la liste n’a pas été rafraîchie.. Solution : Le déclenchement d’une macro appropriée va résoudre le problème Il faut donc, pour actualiser cette liste, décider :

1- quelle action doit être réalisée => quelle action de macro ? 2- quand elle doit l’être => quel événement ?

1°) l’action pour rafraîchir le contenu d’une liste est : « actualiser » (en précisant le nom de la liste). 2°) L’événement à intercepter doit permettre une actualisation de la liste après la mise à jour, l’ajout ou la suppression dans la table « organismes ». Difficulté :


Cette modification peut se faire de plusieurs façons : accès au formulaire « organisme » par clic sur le bouton ajout, par clic direct sur le formulaire « organisme » s’il est déjà ouvert … Le choix de l’évènement est donc délicat, il doit convenir dans tous les cas.


2 cas sont à distinguer :

• La liste et le bouton permettant d’ajouter un élément à la liste sont dans le même formulaire

Evénement à gérer Explications « Sur réception focus » de la liste

Se déclenche dès que le focus arrive sur la liste. Quand on clique sur le bouton, la liste perd le focus (qui est envoyé sur le bouton) et le retour sur la liste déclenche l’événement « sur réception focus ».

• La liste est dans un sous-formulaire et le bouton ajout se situe dans le formulaire principal.

Evénement à gérer Explications « Sur entrée » du contrôle sous-formulaire dans le formulaire principal

Se déclenche dès que le focus arrive sur le sous-formulaire. Quand on clique sur le bouton dans le formulaire principal, le focus quitte le sous-formulaire. Quand on revient, le sous-formulaire reçoit donc de nouveau le focus.

Acces gère 2 focus : 1 pour le formulaire principal (ex : focus1) et 1 pour le sous-formulaire (ex : focus2). Quand on clique sur le bouton ajout du formulaire principal, le focus1 passe du contrôle sous-formulaire au bouton. Par contre, le focus2 reste sur la liste. Après l’ajout, quand on revient dans le sous-formulaire, le focus1 passe du bouton au contrôle sous-formulaire. Le focus2 n’a quant à lui pas quitté la liste. Ce qui explique que l’on ne peut pas gérer l’événement « sur réception focus » de la liste dans ce cas. Nb : pour gérer l’événement « Sur entrée » du contrôle sous-formulaire, se placer en mode création dans le formulaire principal et cliquer sur le sous-formulaire (cf. ci-dessous).

Synthèse :

Cas à gérer Evénement Action Liste + bouton dans le même formulaire

Sur réception focus de la liste Actualiser

Liste dans le sous-formulaire « Sur entrée » du contrôle Actualiser


et bouton dans le formulaire principal

sous-formulaire dans le formulaire principal


Actualiser une liste dans un sous-formulaire en Access 2000

Dans access97, il suffit de créer une macro « Actualiser » Dans Access2000, la macro « actualiser » ne marche pas pour les contrôles placés à l’intérieur d’un sous-formulaire. Il faut donc le faire en code. (utiliser le générateur de code sur l’événement). On a les 2 cas suivants :

• La liste et le bouton permettant d’ajouter un élément à la liste sont dans le même formulaire

Evénement à gérer Code à écrire

« Sur réception focus » de la liste

Nom_liste .requery

• La liste est dans un sous-formulaire et le bouton ajout se situe dans le formulaire principal.

Evénement à gérer Code à écrire

« Sur entrée » du sous-formulaire

Forms !nom_formulaire !nom_du_SF.form !Nom_liste.requery

Dans ce dernier cas, il faut mettre le chemin complet pour accéder à la liste qui se trouve dans le sous-formulaire (d’où le « .form »).


Masques de saisie On peut proposer des masques de saisie pour faciliter l'entrée de données et pour contrôler les valeurs que les utilisateurs peuvent taper dans un contrôle de zone de texte. Par exemple, vous pouvez créer un masque de saisie pour un champ Téléphone qui vous montre exactement comment taper un nouveau numéro: __-__-__-__-__. Exemple de masque pour saisir un numéro de téléphone.

Les masques de saisie permettent d’apporter de l’ergonomie à l’application et guident l’utilisateur dans la saisie. Pour appliquer un masque de saisie, il faut paramétrer la propriété « masque de saisie » du contrôle. Vous pouvez définir un masque de saisie en utilisant les caractères suivants : Caractère Description

0 Chiffre (0 à 9, entrée obligatoire, signes plus (+) et moins (-) non acceptés). 9 Chiffre ou espace (entrée facultative, signes plus et moins non acceptés). # Chiffre ou espace (entrée facultative, positions vierges converties en espaces en

mode édition, mais les espaces sont effacés lors de la sauvegarde des données, signes plus et moins acceptés).

L Lettre (A à Z, entrée obligatoire). ? Lettre (A à Z, entrée facultative). A Lettre ou chiffre (entrée obligatoire). a Lettre ou chiffre (entrée facultative). & Caractère quelconque ou espace (entrée obligatoire). C Caractère quelconque ou espace (entrée facultative). . , : ; - / Séparateur de décimales, de milliers, de date et d'heure (le caractère

effectivement utilisé dépend des paramètres de la boîte de dialogue Propriétés pour Paramètres régionaux du Panneau de configuration Windows).

< Convertit tous les caractères en minuscules. > Convertit tous les caractères en majuscules. ! Permet un remplissage du masque de saisie à partir de la droite et non de gauche

à droite, lorsque les caractères situés à gauche du masque de saisie sont facultatifs. Les caractères tapés dans le masque le remplissent toujours de la gauche vers la droite. Le point d'exclamation peut être placé n'importe où dans le masque de saisie.

\ Affiche le caractère qui suit sous sa forme ASCII littérale (par exemple, \A s'affiche sous la forme A).

Exemple de masque pour un numéro de téléphone : 00\.00\.00\.00\.00\. Exemple de masque pour une date : 00/00/00


Test de cohérence d’un enregistrement avant son ajout/modification

Il peut être parfois utile de tester la cohérence d’un enregistrement avant de valider son insertion ou sa mise à jour dans une table. Principe : avant d’ajouter ou de modifier un enregistrement, on teste la cohérence de la saisie et on ne procède à l’écriture de l’enregistrement dans la table que si la cohérence est respectée. On doit donc procéder à un test avant l’écriture de l’enregistrement dans la table. Pour cela, on gère l’événement « avant MAJ du formulaire » qui se déclenche juste avant qu’ACCESS ne valide l’ajout ou la modification d’un enregistrement dans la table. Si la cohérence n’est pas respectée (condition de macro non remplie), on annule l’événement de mise à jour (action annuler événement). Exemple de test :

Condition Action CpteDom("libelle_race";"t_race";"libelle_race = forms!f_race!zt_libelle_race")>=1

AnnulerEvénement

… BoîteMsg Dans l’exemple ci-dessus, si le libellé saisi existe déjà dans la table, on annule l’insertion du nouvel enregistrement. Nb : la condition testée dépend bien évidemment du contexte de l’application.


Tester la cohérence des enregistrements et appliquer la mise a jour et la suppression en cascade

Exposé du problème. Dans une Base de données, il faut pouvoir ajouter, modifier ou supprimer des enregistrements sans que la cohérence de la base de données soit altérée. Soient les tables clients et commandes suivantes :

Clients Commandes Code_ client Nom No_cde Date_cde Code_client C1 Dupont 1 01/05/2001 C1 C2 Durand 2 01/01/2002 C2 C3 Martin 3 21/02/2002 C1 C4 Louis 4 13/03/2002 C4 1er type d’incohérence : en cas d’ajout de données non valides. Si dans la table commande, j’ajoute une commande N°5 avec le code_client « C6 », je crée une incohérence car le client C6 n’existe pas dans la table clients. 2ème type d’incohérence : en cas de modifications ou de suppressions de données sans répercussions dans les tables liées. Exemple : je modifie le code du client Dupont. Je change donc le code C1 en C10. Si je ne mets pas à jour la table commande, les commandes N°1 et 3 ne sont plus valides car elles sont enregistrées pour un code_client qui n’existe plus. On a le même problème si on supprime par exemple le client « Durand ». Dans ce cas, la commande N°2 est incohérente. Solutions à apporter. 1°) Pour éviter les incohérences dans le cas d’ajouts de données non valides

a) la première solution consiste à tester la saisie au niveau du formulaire. Dans notre exemple, on s’assurera sur le formulaire commandes qu’on ne peut saisir qu’un code_client qui existe dans la table clients (par l’emploi d’une liste fermée par exemple). Inconvénients de cette solution : le test n’est placé que sur le formulaire commande. Si l’utilisateur modifie directement la table, il n’y a aucun contrôle de saisie.

b) lier le test de cohérence au niveau des tables Il existe dans Access des procédures automatiques pour tester la cohérence des enregistrements entre 2 tables. Ces procédures s’activent en allant dans le menu « Outils / Relations ». Etapes à suivre :

- placer les tables dans le menu « Outils / relations » - créer les relations entre les tables - double-cliquer sur la relation et activer l’option « Appliquer l’intégrité référentielle ».


Exemple :

NB : pour appliquer l’intégrité référentielle il faut :

1- que les 2 champs soient du même type de données (on ne peut pas lier un champ texte avec un champ numérique). Rappel : l’équivalent d’un champ « numéro auto » est un champ numérique de type entier long.

2- Qu’il n’existe pas dans les 2 tables des données qui soient incohérentes (ex : une commande avec un code_client qui n’existe pas dans la table clients).

2°) Pour répercuter les modifications ou suppressions dans les tables liées. Quand on supprime ou modifie un enregistrement, il faut vérifier que les enregistrements liés restent cohérents. 2 solutions sont possibles pour assurer cette cohérence :

a) empêcher la suppression d’un enregistrement s’il existe des enregistrements liés Exemple : si l’utilisateur veut supprimer le client C1, on teste auparavant s’il existe des commandes passées par C1. Dans ce cas, on interdit la suppression de C1 et on demande à l’utilisateur d’aller supprimer toutes ses commandes avant de le supprimer. Avantages : c’est l’utilisateur qui décide quoi supprimer Inconvénients : la suppression d’un enregistrement peut être très lourde car l’utilisateur est obligé de supprimer lui-même tous les enregistrements liés.

b) Avant de supprimer un enregistrement : on supprime tous les enregistrements liés dans les tables.

1- Par l’écritures de macros appropriées Avant de supprimer un client, on cherche s’il existe des commandes liées (par une requête sélection). Dans ce cas, on supprime les commandes liées avant de supprimer le client (par une requête de suppression). Avantages : avant la suppression d’un enregistrement, on peut montrer à l’utilisateur la liste de tous les enregistrements liés qui vont être supprimés et lui demander ainsi de confirmer son choix. Inconvénients : il faut programmer soi-même toutes les suppressions ou modifications dans les tables liées.


2- automatiquement Dans l’écran Outils/relations, quand on a appliqué l’intégrité référentielle (cf. ci-dessus), on peut ensuite appliquer la mise à jour et la suppression en cascade. Dans ce cas, Access crée lui-même des procédures de suppressions des enregistrements liés. Exemple :

Ces procédures de mise à jour particulières sont appelées des « triggers ». Access associent ces procédures aux événements « Sur Ajout » et « Sur mise à jour » de la table. (ces événements ne sont pas accessibles à l’utilisateur). Quelque soit l’endroit où la modification ou la suppression est effectuée (dans un formulaire de saisie ou directement dans la table), les répercussions dans les tables liées se font toujours. NB : La modification / suppression en cascade n’est toujours activée que d’un côté de la relation : du côté de la table qui contient la clé étrangère. Dans le cas des tables clients et commandes, c’est la mise à jour ou suppression d’un client qui entraînera la modification ou suppression en cascade des commandes (et non l’inverse). NB2 : Les modifications ou suppressions en cascade s’activent entre 2 tables : il faut donc le faire pour toutes les tables du modèle. Ex : si on supprime un client, il faut supprimer toutes les commandes correspondantes mais également toutes les lignes commandes. Pour cela, il faut activer la mise à jour en cascade sur la relation entre clients et commandes et sur la relation entre commandes et lignes_commandes. Avantages : toutes les suppressions et modifications dans les tables liées se font automatiquement. Inconvénients : En cas de suppression ou modification en cascade, ACCESS ne propose que le message suivant à l’utilisateur :

S’il va trop vite ou qu’il ne comprend pas bien le sens du message, il peut ainsi effacer tous les enregistrements liés sans s’en rendre compte. Comme ces procédures sont gérées automatiquement par Access, il n’y a pas de possibilité de proposer un autre message à l’utilisateur.


Comment définir le contenu d’une liste depuis une autre liste ?

La première liste permet de choisir un client, la deuxième affiche les commandes du client sélectionné.

Soit un formulaire F1 indépendant contenant deux listes lm_client et lm_cde, elles aussi indépendantes. Les listes peuvent être définies à partir d’une table ou d’une requête par contre la requête définissant lm_cde doit intégrer un critère de sélection permettant de choisir le client

Remarque : si l’utilisateur modifie le choix du client, la liste commande doit afficher les commandes correspondantes . Pour cela, il faut actualiser la liste. : faire une macro « actualiser » sur l’événement réception focus, par exemple, de la liste lm_cde.


Principales étapes pour créer une requête a l’aide du module graphique d’Access .

Préalable : bien connaître le modèle et comprendre précisément la question. Dessiner le tableau de résultat attendu peut grandement aider. 1 - Spécifier la (ou les) table(s) intervenant dans la requête = Ecrire le FROM Ce sont les tables contenant la liste des informations à traiter :

• les champs que l’on désire afficher • les champs sur lesquels des calculs donneront les informations à afficher • les champs servant de critères de tri • les champs servant de critères de restriction sur les lignes (WHERE) ou les groupes

(HAVING) • des jointures nécessaires pour relier les tables (jointure classique ou jointure gauche ou

droite) 2 - Spécifier les jointures entre les tables ainsi que le type (classique, gauche ou droite) Voir fiche Jointure. Etablir la jointure entre la clé primaire d’une table et la clé secondaire d’une autre table par un « glisser-déplacer », puis spécifier le type de jointure :

• Jointure classique : Seuls les éléments communs des 2 tables sont affichés • Jointure gauche ou droite : Tous les éléments d’une table sont affichés même si ils

n’ont pas de correspondance dans l’autre table NB : par défaut, les jointures sont classiques. Pour créer une jointure gauche ou droite, double-cliquez sur la jointure. 3 - Spécifier le type de la requête

• Sélection • Ajout • Suppression • Création de table • Mise à jour • Analyse croisée.

4 - Placer les champs à obtenir dans la requête = Ecrire le SELECT A ce niveau, éviter de placer 2 fois le même champ (ex : champ qui se trouve dans 2 tables et qui sert de jointure). 5 - Spécifier les champs calculés et écrire la formule correspondante Ces formules peuvent faire appel à des fonctions mathématiques ou logiques (condition, date,….). NB : le SI en Access s’écrit VRAIFAUX(condition ;action si vrai ; action si faux)


6 - Effectuer éventuellement un regroupement = Ecrire le GROUP BY Menu « Affichage > Opérations ». Quand on crée un regroupement (GROUP BY), il faut s’assurer de la cohérence du groupe créé avec le niveau d’affichage souhaité. Tous les champs doivent être dans le regroupement ou dans une fonction d’agrégation (SUM, MIN, MAX, COUNT …). Choisir pour chaque champ le niveau de regroupement (« Regroupement », « Somme », « Moyenne », « Min » …) (cf. ligne opération dans Access) Les champs contenants des informations plus détaillées et ne servant pas à des agrégations ne doivent pas apparaître dans la requête. 7 - Spécifier les critères de restriction voulus sur chaque champ A ce niveau, on peut mettre un critère « en dur » ou faire référence à un contrôle d’un formulaire (préférable en général).

• restriction sur des lignes d’une table = WHERE • restriction sur l’affichage des groupes (en général sur des fonctions d’agrégation) =

HAVING Dans Access, on placera les critères dans la (les) ligne(s) « critères ». Tous les critères placés sur la même lignes sont combinés avec des « ET ». Des critères placés sur 2 lignes différentes seront interprétés avec des « OU ». 8 - Spécifier éventuellement les ordres de tri Croissant ou décroissant. 9 - Donner un libellé pour les entêtes de colonnes Pour un affichage compréhensible dans le tableau résultat de la requête. C’est en particulier indispensable pour rappeler le sens des champs calculés, ou regroupés.


Les 3 types de jointure pour une requête Lorsque l’on veut afficher des enregistrements provenant de 2 tables différentes qui ont un champ commun, on a souvent recours à une jointure. Le résultat d’une jointure n’affiche les enregistrements des 2 tables que si les valeurs des champs joints remplissent une condition spécifiée. On distingue 3 types de jointure : - la jointure naturelle - la jointure gauche - la jointure droite La plus couramment utilisée est la jointure naturelle qui ne sélectionne les enregistrements des deux tables que si les valeurs des champs joints sont égales. Exemple : soit le modèle suivant :

0,1 1,nVIN

Code vinLibelleMillésimeCouleur

A5A35NA8

MEDAILLECode médailleLibellé médaille

A5A35

Obtenir

FK_VIN_OBTENIR_MEDAILLE

VIN Code vin Code médaille Libelle Millésime Couleur

char(5) char(5) char(35) numeric char(8)

<pk> <fk>

MEDAILLE Code médaille Libellé médaille

char(5) char(35)

<pk>

Les tables VIN et MEDAILLE contiennent les enregistrements suivants :

Code VIN

Nom vin Millésime

Code médaille

Code médaille

Libellé

V1 Château de Jayle 1996 OR AR Argent V2 Château de Jayle 1997 BZ BZ Bronze V3 Château Doistac 1996 OR Or V4 Château Doistac 1997 BZ V5 Clos d’Astourne 1996 AR 1) Le résultat de la jointure naturelle ne fournit que les enregistrements pour lesquels les champs joints sont égaux (ici : le champ joint est le code médaille). On aura donc : Code VIN Nom vin Millésime Libellé médaille V1 Château de Jayle 1996 Or V2 Château de Jayle 1997 Bronze V4 Château Doistac 1997 Bronze V5 Clos d’Astourne 1996 Argent


Le château V3 n’apparaît pas dans la requête car le contenu du champ joint (Code médaille = NULL) ne se trouve pas la table médaille. Dans ACCESS, la jointure par défaut est la jointure naturelle, elle est utilisée lors de la création de requête de sélection. 2) Le résultat de la jointure gauche fournit tous les enregistrements de la 1ère table (côté gauche de l'opération), même si le champ joint de la table située à droite ne contient pas de valeurs correspondantes. Les enregistrements de la table de droite ne sont combinés à ceux de la table de gauche que si les champs joints comportent des valeurs correspondantes. Le résultat pour notre exemple est : Code VIN Nom vin Millésime Libellé médaille V1 Château de Jayle 1996 Or V2 Château de Jayle 1997 Bronze V3 Château Doistac 1996 V4 Château Doistac 1997 Bronze V5 Clos d’Astourne 1996 Argent Dans ACCESS, une jointure gauche est signalée par une ligne de jointure en forme de flèche vers la droite. Pour créer une jointure gauche, il suffit de double-cliquer sur le trait symbolisant l’association. 3) Le résultat de la jointure droite fournit tous les enregistrements de la 2ème table (côté droit de l'opération), même si le champ joint de la table située à gauche ne contient pas de valeurs correspondantes. Les enregistrements de la table de gauche ne sont combinés à ceux de la table de droite que si les champs joints comportent des valeurs correspondantes. Dans ACCESS, une jointure droite est signalée par une ligne de jointure en forme de flèche vers la gauche. Pour créer une jointure droite, il suffit de double-cliquer sur le trait symbolisant l’association.


Principales étapes pour créer un état

1 - Représenter l’état sur une feuille de papier 2 - Analyser ce document :

Faire l’inventaire des informations présentes ou utilisées pour en déduire les tables concernées et donc la requête correspondante

Examiner les résultats calculés et les classer en :

- calculs « simples » portant sur les données d’un seul enregistrement (autant de résultats que d’enregistrements) => à placer dans la requête - calculs de regroupement, dans ce cas, repérer le critère de regroupement, s’il y a plusieurs critères de regroupement, repérer leur enchaînement => à placer dans l’état

3 - Construire la requête en plaçant tous les champs utilisés dans l’état, sans les calculs de regroupement. On peut y inclure les calculs « simples » portant sur chaque ligne de la requête. 4 - Construire l’état :

Attacher l’état à la source de données (requête ou table)

Définir les sections - en- tête de page => menu Affichage / En-tête pied de page - en- tête d’état => menu Affichage / En-tête pied de rapport - détail - pied d’état - pied de page - définir les sections de regroupement en les plaçant selon l’enchaînement des critères repérés. (groupes et sous-groupes) => menu Affichage / trier et regrouper (placer les clés primaires dans l’ordre hiérarchique des groupes et sous-groupes).

Mettre en place les contrôles - indépendants, - dépendants, - calculés (attention : les champs calculés ne peuvent faire appel qu’à des champs placés dans la requête ou à des contrôles placés dans la même section ! ). A ce niveau, la même formule aura un sens différent en fonction de la section dans laquelle elle sera appliquée.

Mettre en forme l’état

Remarque : ne pas attendre d’avoir fini la construction de l’état pour le sauvegarder et le tester ! !


Formulaires de paramétrage pour ouvrir un état sous certaines conditions

Bien souvent, l’ouverture d’un état se fait après avoir spécifié certaines conditions :

contraintes sur une période, sur un service donné, sur un matériel donné ... La solution la plus couramment utilisée consiste à créer un formulaire de paramétrage qui va contenir les conditions. Par exemple : je désire sortir un état en fonction d’une période et d’un service particulier. Je vais donc créer un formulaire de paramétrage pour demander à l’utilisateur de rentrer la période et le service voulus. NB : comme c’est un formulaire de paramétrage, il n’y aura aucune table ou requête source (formulaire indépendant). Il est donc inutile de garder les boutons de déplacement sur enregistrements (mettre la propriété à “ Non ” dans le formulaire).

L’utilisateur a ainsi la possibilité de saisir les dates de la période voulue ainsi que le service. Une fois ces choix effectués, il ne lui reste plus qu’à imprimer ou afficher l’état en cliquant sur un bouton. C’est au moment où on va ouvrir l’état que l’on va appliquer les conditions choisies. Pour que l’état prenne en compte ce filtre, il faut spécifier les conditions dans l’ argument « Condition Where » de la macro associée à l’événement “ Sur_Clic ” du bouton “ Afficher Etat ”. Lors de l’ouverture de l’état, Access exécutera la requête associée à l’état en y ajoutant la condition where spécifiée au niveau de la macro. L’argument condition where attend donc la syntaxe suivante :

« nom d’un champ de la requête » = « valeur du contrôle du formulaire de paramétrage» Nb : les conditions peuvent être combinées Dans l’exemple ci-dessus, condition where : [service]=[Formulaires]![formulaire de paramétrage]![zl_service] and [date] entre [Formulaires]![formulaire de paramétrage]![zt_date_debut] et [Formulaires]![formulaire de paramétrage]![zt_date_fin] Erreur à éviter : mettre le nom d’un contrôle de l’état dans la condition where.


Ex : Condition where : Etats !nom_état!zt_service = Formulaires![formulaire de paramétrage]![zl_service] L’argument « condition where » porte en effet sur la requête. Lorsqu’Access exécute la requête, l’état n’est pas encore formaté et on ne peut donc pas lire les données qu’il contient. Avantage de placer le critère dans l’argument « condition where » de la macro « ouvrir état » : la requête n’est pas spécifique à un état et peut donc être réutilisée. Inconvénient : le texte de l’argument « condition where » est limité à 256 caractères. Si on a une condition trop longue (qui dépasse 256 caractères), on sera donc obligé de placer le critère directement dans la requête). Dans ce cas, la requête ne peut pas être réutilisée car elle dépend du formulaire de paramétrage. Exemple :


Eviter d’ouvrir un état sans enregistrement

Lorsqu’on ouvre un état avec certains critères (saisis par exemple sur un formulaire de

paramétrage), on peut obtenir un résultat qui ne contient aucune donnée lorsqu’aucun

enregistrement ne répond aux critères saisis par l’utilisateur.

Dans ce cas, ACCESS ouvre l’état et n’affiche aucune donnée, ce qui est assez déroutant pour

l’utilisateur.

Pour éviter ce problème, on peut annuler l’ouverture de l’état et afficher un message à

l’utilisateur.

Solution :

Sur l’événement « Sur aucune donnée » de l’état on associera une macro qui contient les 2

actions suivantes :

Action 1 : Boîte message (message = « il n’existe aucune donnée correspondant aux critères

saisis »)

Action 2 : Arrêt toutes macros

Nb : l’action 2 permet d’annuler la macro d’ouverture de l’état. Celui-ci n’est donc pas

affiché.


Afficher les critères de sélection sur l’état

Bien souvent, l’ouverture d’un état se fait après avoir spécifié certaines conditions : contraintes sur une période, sur un client donné, sur une commande particulière ... Un état peut être imprimé et consulté plusieurs jours après son édition. Il faut donc savoir à tout moment quels sont les critères qui ont été utilisés. Pour cela, il est nécessaire de placer sur l’état les critères qui ont été utilisés pour son édition. 2 cas sont alors possibles : 1°) le ou les critères de sélection peuvent être affichés directement à partir du formulaire de paramétrage. Exemple : soit le formulaire de paramétrage et l’état suivants :

Pour recopier les critères de sélection sur l’état, il suffit de créer l’en-tête suivante (le formulaire de paramétrage doit bien sûr rester ouvert) :


Autre exemple : soit le formulaire de paramétrage suivant :

La liste affiche le nom du client mais la colonne liée est le code_client. pour afficher le nom du client sur l’état, il suffit de placer une zone de texte avec la source contrôle suivante : « = formulaires ![f_choix_client] ![lm_clients].colonne(1) » NB : les colonnes d’une liste sont indicées à partir de 0. 2°) le ou les critères ne peuvent pas être affichés directement à partir du formulaire de paramétrage Exemple : soit le formulaire de paramétrage suivant :

Pour afficher le nom du client sur l’état, il est nécessaire de le rechercher à partir du code_client saisi sur le formulaire de paramétrage. Dans l’en-tête d’état, on placera donc une zone de texte avec la source contrôle suivante : « =rechdom(« nom » ; « clients » ; « code_client=formulaires ![f_choix_client] ![zt_clients] ») Par cette instruction, on recherche le contenu du champ « nom », dans la table « clients », pour l’enregistrement pour lequel le code_client est égal à la valeur saisie sur le formulaire de paramétrage.


Comment créer une macro

1 – Création de la macro Si la macro appartient à un groupe de macro, dans la colonne nom de macro, indiquer son nom. Si la macro est conditionnelle (elle déclenche ses différentes actions à partir de différentes conditions), utiliser la colonne condition pour définir ces dernières. Une condition n’est écrite qu’une fois, si elle s’accompagne de plusieurs actions, indiquer trois petits points (…), dans la colonne condition, pour la rappeler. Dans la colonne action, choisir la ou les actions souhaitées, en les plaçant dans l’ordre de leur exécution. Pour chacune, indiquer les arguments correspondants. 2 – Comment exécuter la macro ? La plupart du temps une macro est exécutée à partir d’un événement. Repérer le ou les événements qui devront déclencher l’exécution de la macro, y associer cette dernière en indiquant son nom dans la fenêtre de propriété. Si la macro est appelée depuis une autre macro, utiliser l’action ExécuterMacro. Si la macro est appelée depuis du code en visual basic utiliser la commande : DoCmd.RunMacro « nom de macro ».


Compacter une base de données Tout fichier Access a tendance à occuper une place disque de plus en plus importante au fur et à mesure de son utilisation. Ceci est dû à 2 facteurs :

- la place occupée par les nouveaux objets créés (formulaires, états …) ou par l’ajout de nouveaux enregistrements dans les tables

- de l’espace disque mal géré par Access à chaque utilisation de l’application Il est ainsi possible de remédier au 2ème facteur cité ci-dessus en compactant la base de données. Cette opération crée un nouveau fichier « .mdb » directement utilisable. Etapes à suivre :

1- ouvrir Access sans ouvrir de base de données 2- aller dans le menu « Outils / utilitaires de base de données / Compacter une base de

données » 3- Indiquer le nom du fichier à compacter 4- Indiquer le nouveau nom qui sera attribué au fichier compacté puis cliquer sur le

bouton « enregistrer » La base ainsi compactée :

- permet de réduire la taille du fichier Access - réinitialise tous les champs définis en « numéro auto » pour éviter qu’il y ait des trous

de numérotation (par exemple lorsque des enregistrements ont été supprimés). Attention : en général, quand on utilise un numéro automatique, on ne l'affiche ni sur les formulaires, ni sur les états de sortie (c'est juste un numéro interne qui sert à faire les jointures pour les requêtes et assure l'unicité des enregistrements). Access remet à jour les numéros automatiques à chaque compactage de la base de données. Cela présente l’inconvénient suivant : Ex : vous avez 3 commandes : 1, 2 et 3. Vous imprimez les commandes et les envoyez au client sur support papier. Vous supprimez la commande 2 de la BDD. Il vous reste donc la 1 et la 3. Vous compactez la base => la commande 3 devient la commande 2. Si le client vous appelle avec sa sortie papier, il va vous parler de sa commande N°2 qui n'existe plus dans votre BDD ! Conclusion : si vous avez besoin d'un numéro qui a un sens, on mettra donc plutôt un champ numérique.


Séparation des données et des traitements : tables attachées et lien odbc

Lorsque l’on crée une application, ACCESS met tous les objets (tables, formulaires, états, macros …) dans le même fichier. Ceci peut poser des problèmes pour le déploiement des versions de l’application auprès d’utilisateurs. Imaginons le cas suivant : une version 1.0 (fichier appli1.mdb) est fournie à l’utilisateur qui commence à saisir ses données. Quelques semaines plus tard, une version 2.0 est mise au point, incluant des états et formulaires supplémentaires. Cette version se trouve dans le fichier appli2.mdb. Si l’on écrase chez l’utilisateur le fichier appli1.mdb par appli2.mdb, il aura bien la dernière version de l’application mais perdra les données qu’il avait déjà saisies. La solution consiste donc à séparer les données des traitements dans 2 fichiers différents. 1ère solution : attacher les tables

- on crée un fichier (ex : tables.mdb) qui ne contient que les tables de l’application - on crée un autre fichier (appli.mdb) qui contient tous les autres objets (formulaires,

états, macros …). Ce fichier ne contient donc aucune table. - dans le fichier appli.mdb, on indique dans l’onglet « tables » l’endroit où se trouvent

les tables à interroger. (menu « Insertion/table ; Attacher la table, Nom du fichier qui contient les tables à attacher. Puis choix des tables à attacher).

Access crée alors un lien entre les 2 fichiers. Lorsqu’on exécute le fichier « appli.mdb », Access permet l’interrogation et la mise à jour des tables liées dans le fichier « tables.mdb ». Le déploiement des versions est ainsi facilité :

- lors de la première version, les fichiers tables.mdb et appli1.mdb sont copiées chez l’utilisateur.

- lors de la deuxième version, seul le fichier appli2.mdb sera copié chez l’utilisateur : il gardera donc toutes les données déjà saisies et bénéficiera des nouveaux objets créés.

Cette solution suppose bien évidemment que le modèle des données ne soit plus modifié après la première version. Il faut noter également que lorsqu’access attache les tables d’un fichier, il crée un lien avec un chemin absolu, ce qui signifie que les fichiers « tables.mdb » et « appli.mdb » doivent toujours se trouver dans le(s) même(s) répertoire(s) d’un ordinateur à l’autre. 2ème solution : le lien ODBC Un lien ODBC est une connexion établie sur une base de données et définie au niveau d’un ordinateur donné. Les intérêts d’un lien ODBC sont :

- de pouvoir interroger et mettre à jour une table avec un accès distant - les données et les traitements sont séparés : le déploiement de versions est ainsi facilité



- de pouvoir accéder à une base de données depuis n’importe quel SGBD (ex : un accès Access et un accès Internet avec PHP sur la même base). Le lien ODBC peut en effet être considéré comme un traducteur SQL qui va traduire toutes les requêtes des SGBD dans le format de la base de données choisie.

Etapes à suivre pour Access :

- créer 2 fichiers : un pour l’application seule (ex : appli.mdb) et un autre pour les tables (ex : tables.mdb)

- créer le lien ODBC sur la machine qui pointera sur le fichier tables.mdb : o dans Windows, aller dans le menu « panneau de configuration / Sources de

données ODBC » ou « panneau de configuration / Outils d’administration / Sources de données ODBC ».

o aller dans l’onglet « Sources de données système ». o Cliquer sur « Ajouter » o Choisir le driver correspondant (ici Access) o Indiquer le nom du lien ODBC et sélectionner la base de données à lier (ex : le

fichier tables.mdb) - Dans le fichier appli.mdb, depuis Access, aller dans l’onglet « tables », choisir

« insertion/tables » ; « attacher la table » puis spécifier dans la liste « Type de fichiers » l’option « Base de données ODBC ». Aller dans l’onglet « Sources de données machine » et cliquer sur le nom du lien ODBC que vous avez créé. Puis choisissez les tables à attacher.

Inconvénients du lien ODBC :

- il est propre à une machine : si on veut installer la même application sur plusieurs postes, il faut donc créer le lien ODBC sur chaque poste.

- il agit comme un traducteur et les performances sont ainsi dégradées - le lien ODBC pointe sur la base de données avec un chemin absolu. Si on déplace

cette base dans un autre répertoire, il faut donc modifier le lien.

FICHES METHODES ACCESS -...

Documents

Transcript of FICHES METHODES ACCESS -...