Applications de bureau, illustration avec Access

Transcription

Applications de
bureau, illustration
avec Access
Conception de bases de données
http://bdd.crzt.fr
Stéphane Crozat
14 septembre 2016
Table des
matières
I - Applications de bureau, illustration avec Access
1. Introduction à Access
4
................................................................................................................ 4
1.1. Présentation d'Access .......................................................................................................................................... 4
1.2. Avantages et inconvénient d'Access
................................................................................................................. 6
1.3. Séparation base de données et application
..................................................................................................... 6
2. Création de schéma relationnel sous Access
2.1.
2.2.
2.3.
2.4.
2.5.
Exercice ................................................................................................................................................................ 7
Création de tables sous Access
........................................................................................................................ 8
Domaines et types de données sous Access
.................................................................................................. 9
Contraintes ......................................................................................................................................................... 10
Vues et "requêtes" LDD
................................................................................................................................. 11
3. Le langage de requêtes sous Access
3.1.
3.2.
3.3.
3.4.
3.5.
........................................................................... 7
...................................................................................... 12
Exercice ..............................................................................................................................................................
Questions QBE ..................................................................................................................................................
Questions SQL ...................................................................................................................................................
Manipulation des données en QBE
................................................................................................................
Clause GROUP BY en QBE
.........................................................................................................................
4. Création d'application Access (formulaires et macros)
4.1.
4.2.
4.3.
4.4.
4.5.
......................................................... 15
Exercice ..............................................................................................................................................................
Formulaire liés à une table
............................................................................................................................
Formulaires indépendants ..................................................................................................................................
Contrôles listes ..................................................................................................................................................
Macros ................................................................................................................................................................
5. Modules de programmation VBA sous Access
16
16
18
20
21
..................................................................... 22
5.1. Exercice ..............................................................................................................................................................
5.2. Structure d'un programme VBA
.....................................................................................................................
5.3. Fonctions à connaître
......................................................................................................................................
5.4. Objets VBA pour accéder à la BD
..............................................................................................................
5.5. Aide et déboguage .............................................................................................................................................
5.6. Exemple : Parcourir une table ou une requête stockée
..............................................................................
5.7. Exemple : Parcourir une table passée en paramètre
...................................................................................
5.8. Exemple : Parcourir une table et gérer les erreurs
....................................................................................
5.9. Exemple : Exécuter une requête
......................................................................................................................
5.10. Exemple : Créer un schéma de BD et initialiser les données
................................................................
5.11. Exemple : Normaliser des chaînes de caractères
........................................................................................
5.12. Exemple : Accéder à un fichier externe
......................................................................................................
6. En résumé : Access
12
12
13
14
15
23
23
23
23
24
24
25
25
25
26
26
26
.................................................................................................................. 27
7. Bibliographie commentée sur Access
8. Questions-réponses sur Access
II - Application : Access
...................................................................................... 27
................................................................................................ 28
30
1. Exercice : Chaîne alimentaire
.................................................................................................. 30
2. Exercice : L'apprenti chimiste
.................................................................................................. 32
3. Exercice : Réparation de tondeuses
........................................................................................ 33
III - Test : Access
35
IV - Pratique : Initiation à Access (base de données et application)
38
1. Exercice : Création de la base de données
2. Exercice : Mise en place de l'application
........................................................................... 38
.............................................................................. 51
3. Exercice : Formulaire d'alimentation de la BD
.................................................................... 53
4. Exercice : Formulaire d'interrogation de la BD
................................................................... 59
5. Exercice : Automatisation de l'application par les macros
.................................................. 59
6. Exercice : Prise en main de l'environnement VBA
............................................................. 63
7. Exercice : Automatisation de l'application en VBA
............................................................. 63
8. Exercice : Alimentation de l'application en VBA
................................................................. 64
9. Exercice : Manipulation des données en VBA
...................................................................... 65
V - Pratique : Initiation à Access VBA
67
1. Exercice : Déclaration de la base de données en SQL
2. Exercice : Test des instructions SQL
....................................................... 67
..................................................................................... 69
3. Exercice : Programme VBA d'exécution SQL
....................................................................... 74
VI - Compléments
1. Pratique : Approfondissement de la création d'application sous Access 77
........................... 77
1.1. Exercice : Alimentation de la BD (amélioration)
........................................................................................ 77
1.2. Exercice : Interrogation de la BD (amélioration)
........................................................................................ 78
1.3. Exercice : Automatisation de l'application (amélioration)
............................................................................ 79
Questions de synthèse
80
Solutions des exercices
85
Abréviations
101
Webographie
102
Index
103
Applications de bureau, illustration avec Access
Applications de
bureau, illustration
avec Access
I
Access est un SGBDR * du monde Microsoft Windows qui présente des particularités intéressantes
dans le cadre de ce cours. Il propose une implémentation stricte des concepts relationnels, et ce
dans un cadre facile d'accès techniquement : il constitue un bon moyen d'accès aux technologies des
*
BD * . C'est également un outil intéressant pour prototyper des applications de BD ou pour réaliser
des applications finales dans des cadres d'usage restreint ou bureautique.
*
1. Introduction à Access
Objectifs
Découvrir un SGBD simple d'usage
Découvrir des principes de maquettage rapide d'application BD
1.1. Présentation d'Access
Access est un SGBDR et un outil de création d'application qui permet de :
- Créer des schémas relationnels et donc créer des tables, des contraintes sur les champs de ces
tables et des contraintes référentielles entre ces tables
- Saisir des données dans les tables, avec l'instruction standard LMD * INSERT ou à travers
une interface graphique composée de formulaires
- Écrire des requêtes et des vues en utilisant le langage SQL * ou bien le formalisme graphique
*
*
QBE
*
*
- Réaliser des formulaires permettant d'alimenter ou interroger la BD *
- Réaliser des états permettant de mettre en forme des résultats de requête de type SELECT
- Réaliser des macros permettant de programmer une application complète
- Réaliser des modules VBA permettant également de programmer une application complète,
avec un spectre plus évolué que celui des macros
*
4
Avantages et inconvénient d'Access
Liste et fonctions des objets manipulables avec Access
5
Séparation base de données et application
1.2. Avantages et inconvénient d'Access
Avantages
-
Rapidité de mise en œuvre
Facilité de maintenance ou reprise
Rapidité de création d'IHM
Langage graphique permettant un apprentissage rapide
Schéma de données robustes (intégrité référentielle, contraintes, type de données, etc.)
Inconvénient
-
Utilisation restreinte aux plate-formes Microsoft Windows
Fiabilité douteuse
Résistance faible à la montée en charge
Peu adapté à des logiques réseaux
Système de sécurité non standard, complexe et inadapté
Faiblesse des IHM pour des applications complexes
Cas d'usage
Access est recommandé pour :
- L'apprentissage des BD.
- Le prototypage rapide de BD et d'application (précision de cahier des charges, dialogue
démonstratif avec les utilisateurs, phase avant la réalisation avec un SGBD industriel, etc.).
- Les petites applications locales ou LAN, avec peu d'utilisateurs (dizaines) et un volume de
données raisonnable (centaines de milliers d'enregistrements, méga-octets).
- Les applications ne pouvant être maintenues par des informaticiens.
1.3. Séparation base de données et application
Conseil
Access est à la fois un SGBDR * permettant de créer des BD * et à la fois un outil de
développement d'application. Il est recommandé, pour des raisons méthodologiques et pratiques de
bien séparer ces deux aspects du problème.
*
*
Méthode : Séparation BD / Application
Pour créer une application complète sous Access, créer deux fichiers ".mdb", l'un contiendra la base
de données (uniquement les tables et les vues sous forme de requêtes), l'autre l'application (les
formulaires, états, macros et modules VBA).
Pour relier les deux applications, créer des tables liés dans le fichier "application", à l'aide du menu
"Fichier / Données externes / Lier les tables"
6
Création de schéma relationnel sous Access
Avantages de cette séparation
- Séparation des problématiques de développement
On ne fait pas à la fois le travail de modélisation de la BD et le travail de réalisation d'une
application d'exploitation de cette BD.
- Utilisation en réseau LAN
Une BD centrale sur un serveur et N applications clientes locales.
- Diminution des risques de crash
Le crash de l'application cliente n'affecte pas la BD contenant les données.
- Facilité de maintenance
La mise à jour de l'application ne remet pas en cause la BD et ne nécessite pas de couper
temporairement l'accès au données. Les développements d'évolution de l'application Version
N peuvent se poursuivre en parallèle de l'exploitation de la version N-1, sans avoir besoin de
remettre à jour les données. L'extension du schéma relationnel peut se faire de façon
transparente pour les applications.
- Sécurité
Plusieurs applications différentes peuvent utiliser la même base de données, tout en
travaillant sur des tables différentes.
Remarque : Maintenance
Toutes les modifications concernant la structure de la base de données (donc les tables) doivent être
faites dans le fichier de la base de données et toutes les autres modifications doivent être faites dans
le fichier de l'application (formulaires, états, etc.)
2. Création de schéma relationnel sous Access
Objectifs
Connaître les éléments techniques de base pour apprendre à créer une BD sous Access
2.1. Exercice
[solution n°1 p.85]
Que renvoie la procédure VBA suivante sous Access ?
1 Function F() As Integer
2 Dim vCodeSql(2) As String
3 vCodeSql(1) = "create table Table1 (Champs1 Integer)"
4 vCodeSql(2) = "insert into Table1 (Champs1) values (1)"
5 For i = 1 To 2
6
CurrentDb.CreateQueryDef("", vCodeSql(i)).Execute
7 Next i
8 CurrentDb.CreateQueryDef("", vCodeSql(2)).Execute
9 Set vRs = CurrentDb.CreateQueryDef("", "select sum(Champs1) AS result from Table1").OpenRecordset
10 F=vRs!result
11 End Function
7
[ *]
Création de tables sous Access
2.2. Création de tables sous Access
En général la création de la base se fera en utilisant l'interface graphique d'édition de table (mode
Création), puis en déclarant les attributs un par un en mode interactif.
Créer une table en mode interactif (Créer > Création de table)
8
Domaines et types de données sous Access
Créer une table en mode interactif (définition des attributs)
Méthode : Création du schéma en mode interactif
L'inconvénient de cette façon de créer la base est qu'il est impossible de recréer automatiquement le
schéma de la base une seconde fois.
Complément : Création du schéma en utilisant le LDD
Il est possible de créer le schéma relationnel dans Access en utilisant des instructions LDD * . Il faut
*
pour cela créer une nouvelle requête, passer en mode SQL et écrire chaque requête SQL * une par
une. Cette solution est donc peu efficace, à moins d'avoir écrit un petit programme VBA qui lit une
suite d'instructions LDD et peut ainsi procéder à la constitution complète de la base à partir d'un
seul fichier externe.
*
2.3. Domaines et types de données sous Access
Types de données
-
9
Texte
Numérique
Date/Heure
Oui/Non
Monétaire
NuméroAuto
Mémo
Objet OLE
Contraintes
- Lien hypertexte
Remarque : Domaine
Le domaine est un type de données pour lequel on a éventuellement ajouté certaines contraintes
supplémentaires (telles que la taille du champs, la précision d'un numérique, des contraintes de
validité restreignant les valeurs possibles, la présence ou non de la valeur de nullité, etc.)
Remarque : Énumération
Pour créer un type énumération, il faut partir d'un type de données standard, et restreindre le
domaine aux valeurs autorisées spécifiées par l'énumération. On utilise pour cela la propriété "Valide
si" relative à l'attribut concerné, avec une expression du type "Valeur1 ou Valeur2 ou ValeurN".
C'est équivalent à la clause CHECK en SQL standard.
2.4. Contraintes
Contraintes de tables et de colonnes
Access permet d'exprimer les contraintes SQL LDD standard :
- PRIMARY KEY : Sélectionner le ou les attributs concernés puis effectuer un clic droit et
sélectionner Clé primaire.
- NOT NULL : Null interdit = oui dans les propriétés du champs
- UNIQUE : Indexé = Oui - Sans doublons dans les propriétés du champs ou utiliser la
fenêtre Index pour les clés composées de plusieurs attributs
- CHECK : Valide si dans les propriétés du champs ou de la table (pour une contrainte de
table)
Contraintes d'intégrité référentielle
Access permet de spécifier les contraintes d'intégrité référentielle (clause FOREIGN KEY) à travers
la fenêtre Relations (menu Outils de bases de données).
Pour spécifier une contrainte d'intégrité référentielle, il faut
1. afficher les tables concernées
2. glisser-déposer la clé étrangère sur la clé primaire
3. cocher la case Appliquer l'intégrité réferentielle
10
Vues et "requêtes" LDD
Attention
Dans Access le mot "relation" désigne en fait les contraintes d'intégrités référentielles, et non les
tables comme c'est le cas dans la terminologie relationnelle. Ceci est un abus de langage.
Rappel : Contrôle sur les données
Le contrôle sur les données opéré par un SGBD correspond à divers éléments : contrôle du domaine,
mais aussi de l'intégrité référentielle, de la non nullité, etc.
Ces contraintes peuvent être levées : en spécifiant un domaine très permissif (comme les chaînes de
caractères), en supprimant les clause de non nullité, ou bien en supprimant l'intégrité référentielle
(dans la fenêtre Relations d'Access).
La suppression des contraintes peut être nécessaire pour intégrer temporairement des données qui ne
correspondent pas au modèle. Elles devront bien entendu dans ce cas être mises en conformité au
plus vite, et les contraintes pourront alors être réactivées.
Complément : Enumération
Pour déclarer une énumération dans Access, il faut impérativement la spécifier au niveau de la
structure de la base de données, donc au niveau de la propriété Valide si de l'attribut. La
déclaration de cette énumération au niveau d'une liste déroulante dans l'IHM de saisie de la table (
Liste de choix) n'est pas pertinente car c'est uniquement ce "petit bout d'IHM" qui contrôle les
valeurs de l'énumération et non le moteur du SGBD. Donc une autre partie de l'application avec
une autre IHM pourra permettre des valeurs différentes, ce qui n'est pas souhaité.
2.5. Vues et "requêtes" LDD
Il est possible de spécifier des créations de schémas relationnels en utilisant le LDD de SQL classique
sous Access.
Pour cela il faut créer un objet Requête, puis indiquer que c'est une requête de type Création
de table.
Attention : Types non reconnus
Access n'accepte pas toutes les déclarations de type dans ce cadre. Par exemple il n'est pas possible
de déclarer INTEGER(X), mais seulement INTEGER. La contrainte de taille ne pouvant se faire
qu'en mode interactif.
Vues
Sous Access, les objets Requêtes sont enregistrés.
Pour créer une vue, il suffit donc ce créer un objet Requête de Sélection et de l'enregistrer.
En fait, sous Access, la norme et la vue et l'exception la requête au sens d'évanescent (pour exécuter
une requête qui ne soit pas enregistrée comme une vue, il suffit de ne pas enregistrer la requête).
11
Le langage de requêtes sous Access
3. Le langage de requêtes sous Access
Objectifs
Connaître les principes du langage de requête QBE et savoir lire une requête QBE
3.1. Exercice
[ *]
A quelles opérations relationnelles est équivalente l'instruction QBE sous Access ci-dessous :
Une instruction QBE

Restriction( Produit(T1,T2), T1.a=T2.a ET T1.b=T2.b)

JointureNaturelle (T1, T2)

Projection( Produit(T1, T2), a, b)

Jointure (T1, T2, T1.a=T2.a ET T1.b=T2.b)
3.2. Questions QBE
Remarque
L'on parle de QBE pour désigner le langage graphique proposé par Access, même s'il ne s'agit que
d'une inspiration du "vrai" langage QBE proposé par IBM dès 1977 et implémenté dans la base
Paradox en 1985.
QBE
*
*
permet la création de requête LMD
*
*
en mode interactif, sans écrire de code.
Il faut pour cela :
1. Ajouter les tables
2. Réaliser les jointures en glissant-déposant une des propriétés à joindre sur l'autre (par défaut
l'interface joint les clés étrangères et les clés primaires, il est bien entendu possible de
supprimer la jointure).
3. Glisser-déposer les propriétés à projeter sur la grille
4.
12
Questions SQL
4. Effectuer les restrictions sur la ligne "critère" de la grille.
Exemple : Equivalence QBE-SQL
Une requête QBE annotée en SQL
Remarque : Jointure externe
Pour représenter une jointure externe gauche ou droite, afficher les propriétés de la jointure (doubleclic ou clic droit sur le lien), puis sélectionner l'option adéquate.
Une jointure externe gauche
Attention : Joker
Les jokers sous Access ne sont pas standard, ils s'expriment à l'aide des caractères * au lieu de %
pour 0 à N caractères et ? au lieu de _ pour 1 et 1 seul caractère.
3.3. Questions SQL
Pour écrire une requête en SQL sous Access, il suffit de créer objet requête, puis de passer en mode
SQL (menu Créer).
13
Manipulation des données en QBE
Il est ainsi possible d'écrire du LDD (CREATE TABLE) et du LMD (SELECT, INSERT,
UPDATE).
Remarque : Équivalence QBE / SQL
Il est possible de faire des aller-retour entre le mode SQL et le mode Création (QBE).
1. menu Créer ; icône Création de requête ; fermer la fenêtre Afficher la table qui
apparaît (elle n'est utile que pour écrire des requêtes en QBE)
2. mode SQL (en haut à droite)
3. écrire la requête SQL ; cliquer sur l'icône Exécuter pour l'exécuter
Écrire une requête SQL sous Access
3.4. Manipulation des données en QBE
Pour exécuter une requête autre que de type SELECT, il faut changer son type via le menu Créer
lorsque la requête est en mode Création.
- UPDATE : Mise à jour
- INSERT : Ajout
- DELETE : Suppression
Changer le type de requête
Attention : Problèmes de traduction
Des problèmes de traduction dans certaines versions d'Access conduisent à des formulations
hasardeuses des menus. Ainsi "Mettre à jour une requête" signifie "Requête de mise à jour" et
"Supprimer une requête" signifie "Requête de suppression". L'erreur de traduction vient
probablement du double sens de "Update query" et "Delete query" en anglais...
Ces défaut sont supprimés dans les versions récentes d'Access.
14
Création d'application Access (formulaires et macros)
3.5. Clause GROUP BY en QBE
Appliquer la clause GROUP BY se nomme en Access "faire un regroupement". L'interface QBE ne
le permet pas par défaut, il faut au préalable afficher la ligne Opération, qui fera apparaître une
ligne supplémentaire sur l'interface (menu Affichage > Opérations avant Access 2007, bouton
Totaux depuis)
Activer le GROUP BY
Exemple : Regroupement en QBE sous Access et GROUP BY en SQL
Regroupement en QBE
1 SELECT Effet, Avg(Durée) AS MoyenneDeDurée
2 FROM TPotion
3 GROUP BY Effet;
Remarque : HAVING
Pour ajouter une clause HAVING, il suffit d'utiliser la ligne "critère" sous une propriété à laquelle
est appliquée une opération.
4. Création d'application Access (formulaires et macros)
Objectifs
Connaître les éléments techniques de base pour apprendre à créer une application sous Access
Notons que les états ne sont pas traités ici, mais leur apprentissage est aisé une fois le principe
compris pour les formulaires.
15
4.1. Exercice
[ *]
Soit la table tPersonnes et le formulaire fRecherchePersonne suivant. Le formulaire contient un champs
de saisie de texte "Choix" et un bouton "Exec" qui appelle une fonction VBA "fRecherche()".
Table tPersonne et formulaire fRecherchePersonne
1 Function fRecherche()
2 vChoix = "'" + Forms!fRecherchePersonnes!Choix + "'"
3 vCodeSql = "select pkNom from tPersonnes where pkNom=" + vChoix
4 Set vRs = CurrentDb.CreateQueryDef("", vCodeSql).OpenRecordset
5 MsgBox vRs.RecordCount
6 fRecherche = vRs.RecordCount
7 End Function
Quelle est la valeur maximale qui peut-être renvoyée par la fonction fRecherche (répondez "infini" s'il
n'y a pas de valeur maximale) ?
4.2. Formulaire liés à une table
Définition : Formulaire lié
Un formulaire lié est un formulaire qui offre un accès direct à une (et une seule) table.
Pour lier un formulaire à une table il faut désigner le nom d'une table dans la propriété "Source" du
formulaire.
16
Source d'un formulaire
Remarque : Contrôle lié
Dans le cadre d'un formulaire lié, il est possible (et c'est même le seul intérêt) de créer des contrôles
liés. De tels contrôles référencent directement un attribut d'une table (grâce à leur propriété "Source
contrôle") et permettent donc une saisie directe d'information dans la base sans écrire de code SQL
*
*
LMD * .
*
Source d'un contrôle
Conseil : Usage des formulaires liés
Il est plutôt déconseillé de recourir aux formulaires liés, qui, s'ils offrent une première approche très
simple pour créer des interfaces de saisie, reste très limités fonctionnellement. On leur préférera
rapidement les formulaires indépendants et les requêtes LMD
*
*
de type INSERT et UPDATE.
Attention : Formulaire lié et pages multiples
Un formulaire lié, lorsqu'il est en "Mode simple" (valeur de la propriété "Affich par défaut")
comporte autant de "pages" qu'il y a d'enregistrements dans la table liée.
17
Formulaires indépendants
Chaque page permet de modifier l'enregistrement qu'elle matérialise, et la dernière page permet
d'ajouter un nouvel enregistrement.
Par défaut le formulaire s'ouvre toujours sur le premier enregistrement, et il faut donc se déplacer
après le dernier pour en ajouter un nouveau.
Il faut pour cela utiliser les boutons en bas à gauche du formulaire :
Déplacement dans les différents enregistrements d'un formulaire lié
4.3. Formulaires indépendants
Définition : Formulaire indépendants
Les formulaires indépendants ne sont pas liés à une table (leur propriété "Source" est vierge).
Ils servent à récupérer des valeurs en mémoire, dans des variables, avant d'en faire un traitement
par programmation : On pourra par exemple utiliser cette valeur dans une requête SQL
type INSERT pour ajouter des enregistrements dans une table.
*
*
LMD
*
*
de
Il est toujours possible de faire, avec un formulaire indépendant et une requête SQL, ce qu'il est
possible de faire avec un formulaire lié (et l'on peut bien entendu faire beaucoup plus).
18
Formulaires indépendants
Syntaxe
Formulaire indépendant
Pour créer un formulaire indépendant, sélectionner Formulaire vierge dans le menu, et/ou
veiller à ce que la propriété Source du formulaire soit vide.
Remarque : Contrôles et formulaires indépendants
Les contrôles d'un formulaire indépendant ne peuvent bien entendu pas être liés à une table. Ils ne
peuvent servir qu'à stocker une valeur en mémoire pour un usage donné. Ils sont de ce fait
comparable à des variables.
Syntaxe : Utiliser une valeur saisie dans le contrôle d'un formulaire indépendant
Pour utiliser les valeurs indépendantes (en mémoire) de contrôle d'un formulaire, dans d'autres
objets (formulaires, états, requêtes, macros ou modules), utiliser l'une des deux syntaxes suivantes :
1 Formulaires!NomDuFormulaire!NomDuContrôle
1 Forms!NomDuFormulaire!NomDuContrôle
Exemple : Mise à jour de plusieurs tables
1. Saisie de valeurs relatives à plusieurs enregistrements, de tables différentes, dans un formulaire
2. Utilisation de ces valeurs dans des requêtes d'insertion pour ajouter les valeurs dans les tables
1 INSERT INTO TVilles (pkVille, aPays)
2 VALUES (Formulaires!FChoix!Ville, Formulaires!FChoix!Pays)
19
Contrôles listes
Exemple : Requêtes paramétrées
1. Saisie de valeurs relatives à des paramètres dans un formulaire
2. Exécution d'une requête de sélection s'appuyant sur ces paramètres
1 SELECT * FROM TVilles
2 WHERE Pays = Formulaires!FChoix!Pays
4.4. Contrôles listes
Les listes déroulantes sont des contrôles très intéressants qui permettent de récupérer des valeurs
dynamiques grâce à une requête ou de spécifier des valeurs statiques parmi lesquelles l'utilisateur
choisira.
- Pour que les valeurs de la liste soit définies dynamiquement à partir du résultat d'une requête,
fixer la propriété "Origine source" à la valeur "Table/Requête", puis écrire la requête dans la
propriété "Contenu".
- Pour que les valeurs de la liste soit définies statiquement, fixer la propriété "Origine source" à
la valeur "Liste Valeurs", puis lister les valeurs en les séparant par des points-virgules dans la
propriété "Contenu".
Contenu d'un contrôle liste
Remarque : Liste à plusieurs colonnes
Il est possible de réaliser des listes déroulantes à plusieurs colonnes. Il suffit pour cela que la requête
spécifiée dans "Contenu" projette plusieurs attributs.
20
Macros
Il faudra dans ce cas régler correctement les propriétés "Nbre colonnes" (le nombre de colonnes) et
"Colonne liée" (le numéro de la colonne principale, qui renvoie la valeur à stocker reéellement dans
la variable associée au contrôle).
Remarque : Récupération de la valeur d'une colonne d'une liste
1 Formulaires!NomDuFormulaire!NomDuContrôleListe.column(X)
2 Avec X de 0 à N-1, N étant le nombre de colonnes
4.5. Macros
Attention
Un objet "macro" est en fait un objet "groupe de macro". Il faudra afficher les colonnes optionnelles
:
- Noms de macros
- Conditions
- Arguments
Une macro est définie par un nom (première colonne) et une succession d'instructions (actions dans
la dernière colonne) éventuellement soumises à des conditions d'exécution (seconde colonne). Chaque
action requiert de fixer un certain nombre de paramètres qui s'affiche dans la partie basse de
l'interface après que l'action ait été sélectionnée.
Interface de création de macros
Exemple
- OuvrirFormulaire
Ouvre un formulaire
- OuvrirEtat
Ouvre un état
- BoîteMsg
Crée une boîte de dialogue avec l'utilisateur.
- AtteindreEnregistrement
Dans un formulaire lié, permet d'atteindre un enregistrement particulier.
21
Modules de programmation VBA sous Access
- DéfinirValeur
Permet de fixer la valeur de n'importe quelle propriété d'un contrôle de formulaire. Cette
action est très utile pour rendre les interfaces plus dynamiques.
- ExécuterMacro
Exécute une autre macro. Cette action est utile pour modulariser le code Macro (bien que
sans passage de paramètres, cela reste sommaire).
- Fermer
Ferme un objet de type fomulaire, état, etc.
- TrouverEnregistrement
Dans un formulaire lié, permet de se rendre à un enregistrement particulier en fonction de la
valeur de l'un de ses contrôles.
- AtteindreContrôle
Permet de sélectionner un contrôle particulier dans un formulaire. Cette action est utile avant
d'effectuer un TrouverEnregistrement par exemple.
- Actualiser
Permet de rafraîchir un contrôle (après un DéfinirValeur ou pour ré-exécuter la requête
source d'une liste déroulante par exemple )
- Avertissements
Active ou désactive les avertissements lors de l'exécution de requêtes.
- ExécuterCommande
Permet d'exécuter une des commandes disponible dans les menu d'Access
- ArrêtMacro
Stoppe la macro, sans exécuter les instructions restantes. Cette actions est utile pour terminer
la macro après un test par exemple.
Appel des macros
Les macros sont en général appelées par des évènements particuliers survenus lors de la
manipulation des formulaires et états (programmation évènementielle des formulaires et états).
Les macros peuvent également être appelées par d'autres macro, voire du code VBA.
Complément : Macro AutoExec
Si une macro porte le nom "AutoExec", elle sera exécutée automatiquement à l'ouverture de la base
de données.
Cette macro peut servir typiquement à afficher un menu général d'entrée dans l'application.
Pour désactiver l'exécution automatique de la macro AutoExec, maintenez la touche "shift" de
l'ordinateur appuyée lors du lancement de l'application.
5. Modules de programmation VBA sous Access
Objectifs
Découvrir les modalités d'accès à une base de données via un langage de programmation
Savoir accéder à une base de données Access depuis un programme VBA
22
Exercice
5.1. Exercice
[ *]
Que renvoie la fonction VBA ci-dessous :
1 Function FonctionSecrete() As String
2 CurrentDb.CreateQueryDef("", "delete from T1").Execute
3 CurrentDb.CreateQueryDef("", "insert into T1 (a) values ('1')").Execute
5 Set vRs = CurrentDb.CreateQueryDef("", "select * from T1").OpenRecordset
6 x = vRs!a
7 vRs.MoveNext
8 x = vRs!a
9 FonctionSecrete = x
10 End Function
5.2. Structure d'un programme VBA
- Fonction (function)
Retourne une valeur, utilisable dans les requêtes, les formulaires et les états.
- Procédure (sub)
Effectue des opérations, en général sur les tables, notion de procédures stockées
Syntaxe
1 {Sub | Function} nom (param1 As type, ...) {As type retourné}
2 Dim variable1 As type
3 ...
4 {End Sub | End Function}
5.3. Fonctions à connaître
- Traitement de chaîne : LCase(S), UCase(S), Left(S, 1), Right(S, 1), Len(S), +, ...
- Gestion nombre : Cast : Int()...
5.4. Objets VBA pour accéder à la BD
- CurrentDb : Objet base de données
- .CreateQueryDef(nom_requête,code_sql) : Crée un objet requête
"nom_requête" avec le code "code_sql". Si "nom_requête" est renseigné la requête
est enregistrée comme un objet persistant dans la base, si "nom_requête" est vide la
requête n'est pas enregistrée.
- QueryDef : Objet requête
- .OpenRecordset : Exécute une requête de type SELECT
- .Execute : Exécute une requête de type INSERT, UPDATE ou DELETE (ou LDD * )
*
- Recordset : Pointeur sur un résultat de requête
23
Aide et déboguage
- .MoveNext, .MoveFirst, .MoveLast : Atteindre l'enregistrement suivant, le
premier, le dernier
- .RecordCount : Le nombre d'enregistrements du résultat
- .EOF : Booléen permettant de tester si on a atteint à la fin du résultat
- !nom_champ : La valeur du champ "nom_champ"
Syntaxe : Alimentation de la BD
1 CurrentDb.CreateQueryDef("", "INSERT...").Execute
Syntaxe : Interrogation de la BD
1 Set vRs = CurrentDb.CreateQueryDef("", "SELECT...").OpenRecordset
2 Do While Not vRs.EOF
3 ... vRs!MonChamp ...
4 vRs.MoveNext
5 Loop
Remarque : Approche alternative
1 For i = 1 To vRs.RecordCount
2 ... vRs!MonChamp ...
3 vRs.MoveNext
4 Next i
5.5. Aide et déboguage
Attention : Accéder à l'aide en ligne
Pour accéder à l'aide en ligne sur les fonctions VBA demander l'aide (F1) depuis l'éditeur Visual
Basic (Module) et non directement depuis Access.
Attention : Fenêtre d'exécution
La fenêtre d'exécution est indispensable pour tester les programmes VBA.
Pour obtenir la fenêtre d'exécution, faire "Affichage / Fenêtre d'exécution" dans le menu de
l'éditeur VBA / Module.
La syntaxe "Debug.Print" dans un programme permet ensuite d'afficher des informations dans cette
fenêtre (valeur de variable typiquement).
5.6. Exemple : Parcourir une table ou une requête stockée
1 Sub ParcoursTable()
2 Set vRs = CurrentDb.OpenRecordset("MaTable")
4 Debug.Print vRs!MonChamp
5 vRs.MoveNext
24
Exemple : Parcourir une table passée en paramètre
6 Next i
7 End Sub
5.7. Exemple : Parcourir une table passée en paramètre
1 Sub ParcoursTable(pTable As String, pChamp As String)
2 Set vRs = CurrentDb.OpenRecordset(pTable)
3 Set vChamp = vRs.Fields
4 For i = 0 To vChamp.Count - 1
5 If vChamp(i).Name = pChamp Then NumChamp = i
6 Next i
8 Debug.Print vRs.Fields(NumChamp)
9 vRs.MoveNext
10 Next i
11 End Sub
5.8. Exemple : Parcourir une table et gérer les erreurs
1 Sub ParcoursTable(pTable As String, pChamp As String)
2 On Error GoTo Erreur_ParcoursTable
3 Set vRs = CurrentDb.OpenRecordset(pTable)
4 Set vChamp = vRs.Fields
5 For i = 0 To vChamp.Count - 1
6 If vChamp(i).Name = pChamp Then NumChamp = i
7 Next i
9 Debug.Print vRs.Fields(NumChamp)
10 vRs.MoveNext
11 Next i
12 Exit_ParcoursTable:
13 Exit Sub
14 Erreur_ParcoursTable:
15 Debug.Print "Erreur"
16 MsgBox "Erreur"
17 End Sub
5.9. Exemple : Exécuter une requête
1 Sub ExecuterRequete(pTable As String, pChamps As String)
2 Dim vCodeSql As String
3
4 vCodeSql = "select " + pChamps + " from " + pTable
7 Debug.Print vRs.Fields(0)
8 vRs.MoveNext
9 Next i
10 End Sub
25
Exemple : Normaliser des chaînes de caractères
5.10. Exemple : Créer un schéma de BD et initialiser les données
1 Sub InitBD()
2 Const NbLignesSql As Integer = 3
3 Dim vCodeSql(NbLignesSql) As String
4 vCodeSql(1) = "drop table Table1"
5 vCodeSql(2) = "create table Table1 (Champs1 String(150))"
6 vCodeSql(3) = "insert into Table1 (Champs1) values (""test"")"
7 For i = 1 To NbLignesSql
8 CurrentDb.CreateQueryDef("", vCodeSql(i)).Execute
9 Next i
10 End Sub
5.11. Exemple : Normaliser des chaînes de caractères
1 Function NormaliserChaine(s As String) As String
2 Result = ""
3 For i = 1 To Len(s)
4 C = Right(Left(s, i), 1)
5 Select Case C
6 Case "é", "è", "ê"
7 C = "e"
8 Case "à"
9 C = "a"
10 Case "ï"
11 C = "i"
12 End Select
13 Result = Result + C
14 Next i
15 Result = UCase(Left(Result, 1)) + LCase(Right(Result, Len(Result) - 1))
16 NormaliserChaine = Result
17 End Function
5.12. Exemple : Accéder à un fichier externe
Cet exemple (extrait de l'aide en ligne d'Access) utilise la fonction Input pour lire un fichier
caractère par caractère et les afficher dans la fenêtre Exécution. Nous supposons que FICHTEST est
un fichier texte comportant quelques lignes de données.
Exemple
1 Sub LireFichier()
2 Dim MyChar
3 Open "FICHTEST" For Input As #1 ' Ouvre le fichier
4 Do While Not EOF(1) ' Effectue la boucle jusqu'à la fin du fichier
5 MyChar = Input(1, #1) ' Lit un caractère
6 Debug.Print MyChar ' Affiche dans la fenêtre Exécution
7 Loop
8 Close #1 ' Ferme le fichier
9 End Sub
26
En résumé : Access
6. En résumé : Access
Access
À la fois un SGBDR pour créer des BD et un outil de développement d'applications
- BD
Dimension relevant de la conception de BD
- LDD
- Tables
- LMD
- Requêtes (Vue)
- Application
Dimension relevant de la conception d'application.
- IHM
- Formulaires
- États
- Programmation
- Macros
- Modules VBA
7. Bibliographie commentée sur Access
Complément : Pratique
Comprendre les jointures dans Access
*
*
Un tutoriel très pédagogique sur l'expression de jointures sous Access, qui peut par ailleurs servir à
comprendre l'opération de jointure en général si besoin.
Complément : Pour aller plus loin
Developpez.com
*
*
Un portail avec de nombreuses ressources.
FAQ de Développez.com
*
*
Une base de questions très intéressante pour la dimension outils de création d'application d'Access.
On consultera en particulier les informations sur la gestion de la sécurité, les formulaires, VBA.
27
Questions-réponses sur Access
8. Questions-réponses sur Access
Comment supprimer les messages d'alertes lors de l'exécution des requêtes ?
VBA : DoCmd.SetWarnings False
Macro : Avertissements=Non
Comment atteindre un contrôle d'un sous-formulaire ?
Forms![NomFormulaire].form![NomSousFormulaire]![MaZoneDeTexte]
(ici pour une zone de texte)
Comment parcourir un "RecordSet" en VBA?
1 Rst.MoveFirst
2 While not rst.EOF
3 ' code
4 rst.MoveNext
5 Wend
1 Do Until rst.EOF
2 ' code
3 rst.MoveNext
4 Loop
Comment calculer la difference entre 2 dates en VBA ?
1 DateDiff("d", date1, date2)
2 'donne le nombre de jour entre date1 et date2
Comment mettre un point d'arrêt dans un code VBA ?
Quand Access passe sur un point d'arrêt l'exécution du code s'arrête et attends une manœuvre de
votre part pour continuer.
- Quand le code est arrêté vous pouvez connaître la valeur des variables de votre code
simplement en passant le pointeur de la souris dessus.
Vous pouvez choisir de continuer à exécuter le code en mode pas à pas en appuyant sur F8.
Vous pouvez poursuivre l'exécution du code normalement avec F5.
Quel est la diference entre "." et "!" ?
L'opérateur "!" (point d'exclamation) indique que l'élément qui suit est défini par l'utilisateur (un
élément d'une collection). Par exemple, vous pouvez utiliser l'opérateur "!" pour faire référence à un
formulaire ouvert, à un état ouvert, ou à un contrôle figurant sur un formulaire ou sur un état.
28
Questions-réponses sur Access
L'opérateur "." (point) indique généralement que l'élément qui suit est défini par Microsoft Access.
Par exemple, vous pouvez utiliser l'opérateur "." pour faire référence à une propriété d'un
formulaire, d'un état, ou d'un contrôle.
29
Application : Access
Application : Access
II
1. Exercice : Chaîne alimentaire
[45 min]
Une base de données Access permet de représenter différentes espèces d'herbivores, ainsi que les
plantes qu'elles consomment et ce en fonction du continent où l'on trouve les plantes et les animaux.
Modèle logique sous Access
Question 1
[ *]
Rétro-concevoir le modèle UML associé à cette base de données.
Formulaires et requêtes
Les formulaires fPlantes et fMange ont été créés, pour alimenter respectivement les tables
tPlantes et tMange.
30
Exercice : Chaîne alimentaire
Formulaire fPlantes
Formulaire fMange
Pour le formulaire fMange, on souhaite que :
- le champ animal ne propose que des animaux existants dans la base ;
- le champ plante ne propose que des plantes situées sur le même continent que l'animal
choisi.
Question 2
[ *]
Écrire la requête rAlimPlantes permettant d'insérer les données dans la table tPlantes à l'aide
du formulaire fPlantes, sachant que les champs du formulaire sont nommés comme leur étiquette
(le texte qui leur fait face).
Question 3
[ *]
Écrire la requête rAnimal permettant d'initialiser la première liste déroulante du formulaire
fMange.
Question 4
[ *]
Écrire la requête rPlante permettant d'initialiser la seconde liste déroulante du formulaire fMange
.
31
Exercice : L'apprenti chimiste
VBA
Le formulaire fNbPlantesMangees permet de savoir combien de plantes différentes sont mangées
par un animal choisi dans un menu déroulant. Il appelle pour cela une procédure comptePlantes
lorsque l'on clique sur le bouton. La procédure comptePlantes exécute une requête pour compter
le nombre de plantes mangées par l'animal saisi dans le contrôle nom et l'affiche dans une boîte de
dialogue de type MessageBox, comme dans l'exemple ci-après.
Formulaire fNbPlantesMangees
Exemple de MsgBox
Question 5
[ *]
Écrire le code VBA de la procédure comptePlantes.
2. Exercice : L'apprenti chimiste
[15 minutes]
Soit la requête suivante exprimée en QBE sous Access :
32
Exercice : Réparation de tondeuses
Requête en QBE
Question 1
[ *]
Qu'exprime cette requête ?
Question 2
[ *]
Écrivez une requête équivalente en SQL.
3. Exercice : Réparation de tondeuses
[20 min]
Une petite entreprise de réparation de tondeuse, située à proximité de Montpellier, souhaite créer
une nouvelle base de données pour s'occuper de son activité, notamment pour gérer la liste de ses
clients et du matériel en leur possession. Elle s'adresse à vous, car elle utilise Access depuis quelques
années, mais le modèle qu'elle a développé (en totale autonomie) est limité et pose certains
problèmes d'intégrité. Votre expertise serait appréciée pour modifier et corriger la base existante.
Actuellement, la base tient sur une unique table, déjà alimentée car fonctionnelle depuis plusieurs
années.
33
Exercice : Réparation de tondeuses
La table tondeuse
Les données de la table tondeuse
À l'aide du schéma de la table et des données, vous parvenez à la liste des dépendances
fonctionnelles suivantes sous la forme d'une fermeture transitive :
- nucli nom, prenom, adresse, cp, ville
- modele marque, puissance, type, bac
- modele, num_serie
nucli, nom, prenom, adresse,
millesime, date_achat, marque, puissance, type, bac
Question 1
cp,
ville,
[ *]
Énoncez les clés candidates. En quelle forme normale est le schéma de la base existante ? Justifiez
votre réponse.
Question 2
[ *]
Afin de préparer la décomposition du schéma relationnel, proposez une couverture minimale des
DFE.
Question 3
[ *]
Décomposez le schéma relationnel de la base existante, en préservant les DF, pour proposer un
modèle relationnel en 3NF.
Question 4
[ *]
Rétro-concevez le MCD qui aurait permis d'aboutir directement à ce schéma relationnel.
34
Test : Access
Test : Access
Exercice
III
[ *]
Soit la table tPersonnes et le formulaire fRecherchePersonne suivant. Le formulaire contient un
champs de saisie de texte "Choix" et un bouton "Exec" qui appelle une fonction VBA
"fRecherche()".
7 End Function
Quelle est la valeur maximale qui peut-être renvoyée par la fonction fRecherche (répondez "infini"
s'il n'y a pas de valeur maximale) ?
35
Test : Access
Exercice
[ *]
Une instruction QBE




Exercice
[ *]
6 x = vRs!a
7 vRs.MoveNext
8 x = vRs!a
10 End Function
36
Test : Access
Exercice
[ *]
A quelles instructions SQL est équivalente l'instruction QBE sous Access ci-dessous :
Une instruction QBE

SELECT a FROM T1
WHERE T1.a=[formulaires]![F1]![C1];

INSERT INTO T2 (a)
SELECT T1.a FROM T1

INSERT INTO T2 (a)

SELECT a FROM T1, T2
VALUES ([formulaires]![F1]![C1]);
WHERE T1.a=T2.a AND T1.a=[formulaires]![F1]![C1];
Exercice
[ *]
5 For i = 1 To 2
6
7 Next i
10 F=vRs!result
11 End Function
37
Pratique : Initiation à Access (base de données et application)
Pratique : Initiation
à Access (base de
données et
application)
IV
Objectifs
Apprendre à se servir d'Access
Expérimenter les concepts de SGBDR
Au cours de de la première partie du TP, vous allez devoir concevoir une BD, puis l'implémenter
sous Access.
L'usage des assistants est formellement interdit (Si un assistant apparaît involontairement, annuler
et continuer manuellement).
1. Exercice : Création de la base de données
Mise en situation
Vous êtes le président de l'association "Objectifs", dont l'objet est d'aider ses étudiants membres à
mener des projets dans le cadre de leurs études. Cette association a besoin d'une base de données
pour gérer ses projets.
38
Exercice : Création de la base de données
État des projets de l'association Objectifs
Vous réalisez un modèle conceptuel permettant de traiter le problème.
Modèle UML de la base de données de gestion de projets
39
Modèle E-A de la base de données de gestion de projets
Vous décidez de commencer par un sous-ensemble de la base de données, permettant de gérer les
projets, les spécialités et les chefs de projet uniquement, tel que formalisé sur le schéma relationnel
ci-après.
1 Projet (#Num, Nom, Debut, Fin, ChefDeProjet=>Membre, Specialite=>Specialite
2 Specialite (#Intitule)
3 Membre (#Prenom, Nom, Specialite=>Specialite)
Vous décidez d'utiliser Access pour implémenter votre BD.
Question 1
Justifiez le choix d'Access pour votre application en quelques arguments.
Question 2
Créer la base de données assoBd.mdb.
Indice :
À partir de l'écran d'accueil d'Access :
1. Choisir une base de données vide
2. Nommer la base
3.
40
3. Cliquer sur créer
Créer une base de données
Question 3
Créer les trois tables tProjet, tSpecialite et tMembre.
Indices :
Pour nommer les tables, il est fortement conseillé sous Access d'adopter une convention qui
consiste à préfixer le nom de la table d'un "t" (pour table).
Pour créer une table :
1. Cliquer sur Créer > table
2. Cliquer sur Affichage > Mode Création
3. Saisir le nom de la table
41
Créer une table
42
Créer une table (passer en mode création)
Pour déclarer les attributs d'une table
1. Saisir le nom de chaque attribut
2. Associer son type via la liste déroulante
3. Documenter l'attribut dans la colonne description
Les contraintes sont à spécifier dans la zone du bas :
-
43
Taille du champ
Valide si (CHECK)
Null interdit et Chaîne vide autorisée (NOT NULL)
Indexé > Oui - Sans doublons (UNIQUE)
Déclarer les attributs
Question 4
Déclarer les clés primaires et les clés candidates. Déclarer une clé candidate composée, par exemple
(Nom, Debut) pour la relation Projet.
Indice :
Pour déclarer les clés :
1. Pour la clé primaire (si elle n'est pas composée), sélectionner l'attribut et cliquer sur le
bouton Clé primaire.
2. Pour les clés candidates spécifier : Null interdit > oui (et chaîne vide non
autorisée le cas échéant) et Indexé > Oui - Sans doublon.
3. Plus généralement et notamment pour les clés composées, passer par le menu Création
> Index.
44
Déclarer la clé primaire
45
Déclarer une clé candidate
46
Déclarer une clé composée
Question 5
Déclarer les contraintes d'intégrités référentielles sur les clés étrangères.
Indice :
1.
2.
3.
4.
47
Cliquer sur Outils de base de données > Relation
Ajoutez toutes les tables de votre base de données
Glisser-déposer chaque clé étrangère sur la clé primaire référencée
Cliquez sur l'option "Appliquer l'intégrité référentielle"
Activation des contraintes d'intégrité référentielle
48
Déclaration des contraintes d'intégrité référentielle
Question 6
Ajouter une vue vProjet permettant de renvoyer les projets avec leurs membres.
1 vProjet = jointure (Projet, Membre, Projet.ChefDeProjet=Membre.Prenom)
Indice :
Dans Access un objet "Requête" est une vue.
Pour ajouter une vue :
1. Cliquer sur Créer > Création de requête
2. Sélectionner les tables utilisées dans la requête (ou annuler le menu d'ajout de table pour
écrire la requête directement en SQL ou spécifier les tables ultérieurement)
3. Enregistrer (CTRL+S) pour nommer votre requête
La requête peut ensuite être écrite en utilisant le langage graphique d'Access ou directement en
SQL.
49
Créer une vue
50
Exercice : Mise en place de l'application
Passer en mode SQL
2. Exercice : Mise en place de l'application
Votre BD réalisée, vous décidez à présent de commencer la réalisation de l'application. Pour cela
vous vous faites aider par un membre de l'association, Pierre, qui connaît bien le problème de la
gestion des projets dans "Objectifs", et qui par ailleurs à une bonne expérience de la conception des
IHM.
Prenez connaissance des propositions d'interface pour l'ajout et la recherche de projets que vous a
faites Pierre.
51
Exercice : Mise en place de l'application
Interface d'ajout de projets
Interface de recherche d'un projet
Question 1
Afin de préparer la réalisation de l'application, créez un second fichier "assoAppli.mdb", et reliez-le
à celui contenant votre BD ("assoBd.mdb").
Indice :
Pour relier 2 fichiers Access :
1.
2.
3.
4.
5.
Ouvrir le fichier de l'application qui va référencer le fichier de la base de données
Cliquer sur Données Externes > Access
Sélectionner votre fichier de base de données
Sélectionner l'option Lié à la source de données...
Sélectionner toutes les tables
Les tables apparaissent dans l'application, précédées d'une flèche, qui indique qu'elles sont en
fait physiquement dans un autre fichier.
52
Exercice : Formulaire d'alimentation de la BD
Accès à la base de données depuis l'application
Question 2
Décrivez le processus de conception que vous avez adopté pour réaliser votre base de données, en en
décrivant les différentes étapes, et après avoir rappelé en quoi et pourquoi l'on sépare la conception
de la BD de ses applications.
Donnez un exemple concret dans le cas de votre réalisation de problème qui justifie cette séparation.
3. Exercice : Formulaire d'alimentation de la BD
Réaliser un unique formulaire indépendant permettant de saisir un nouveau projet, avec :
- Son numéro, son nom, son début et sa fin.
- Son chef de projet
- Sa spécialité
Les participations des membres de l'association au projet, les partenaires, et les tâches ne sont pas
à définir à ce stade, ils s'inscriront ultérieurement grâce à un autre formulaire qui n'est pas à
réaliser dans le cadre de cette question.
Formulaires indépendants (cf. p.18)
Question 1
Créer le formulaire en utilisant uniquement des contrôles de type "zone de texte".
53
NB : La réalisation d'interfaces avancées n'est pas le but de ce TP, même si vous avez la possibilité
d'aller plus loin en traitant les questions suivantes.
Indices :
Il est conseillé de préfixer les noms des formulaire par un "f".
Pour créer une formulaire indépendant :
1.
2.
3.
4.
Cliquer sur
Cliquer sur
Enregistrer
Cliquer sur
Créer > Formulaire vierge
Affichage > Mode création
pour le nommer (CTRL+S)
Création > Feuilles de propriétés
Créer un formulaire indépendant
54
Passer un formulaire en mode création
55
Afficher les propriétés du formulaire ou d'un contrôle
Pour ajouter un contrôle :
1. Cliquer sur le type de contrôle dans le menu Création
2. Cliquer sur l'endroit du formulaire où il doit être ajouté
3. Lui donner son nom dans la feuille de propriétés
Penser à donner un nom explicite à chaque contrôle, comme par exemple les trois premières
lettres de l'attribut auquel il correspond.
56
Ajouter un contrôle de type zone de texte
Pour tester un formulaire, passer le en mode formulaire.
Question 2
Créez une requête de type Ajout (INSERT) permettant d'ajouter les nouvelles informations dans
la table tProjet depuis le formulaire.
Indices :
57
Créer une requête de type INSERT
Il est conseillé de préfixer les noms des requêtes par un "r".
Pour écrire une requête directement en SQL, sans passer par l'interface graphique, choisissez
"Affichage > Mode SQL".
Pour l'exécuter cliquer sur Exécuter.
La syntaxe suivante permet de récupérer la valeur courante d'un contrôle d'un formulaire ouvert
: Formulaires!NomDuFormulaire!NomDuContrôle
Dans une instruction SQL on peut donc écrire : INSERT INTO t (attribut) VALUES
(Formulaires!NomDuFormulaire!NomDuContrôle)
où
Formulaires!
NomDuFormulaire!NomDuContrôle sera remplacé par sa valeur courante dans le formulaire.
Le formulaire doit donc être ouvert, et des valeurs doivent être saisies et validées, pour que la
requête s'exécute correctement.
1 INSERT INTO tProjet
2 (pknum, nom, ...)
3 VALUES
4 (Formulaires!fProjet!num, Formulaires!fProjet!nom, ...)
Question 3
Testez votre application en insérant des données, vérifier que les contraintes d'intégrité sont bien
contrôlées.
58
Exercice : Formulaire d'interrogation de la BD
4. Exercice : Formulaire d'interrogation de la BD
Réaliser une vue dont la requête source est paramétrée par un formulaire, afin de rechercher les
projets tels que leur nom contient un (unique) mot clé donné dans le formulaire.
Le numéro et le nom seront projetés.
Question 1
Créer le formulaire de recherche fRecherche.
Question 2
Créer la vue vRecherche.
Indices :
Pensez à l'usage de l'opérateur de comparaison de chaîne LIKE.
Le caractère de concaténation est "&" et le joker "*" désigne plusieurs caractères ("*" est sous
Access équivalent au caractère "%" standard en SQL).
1 SELECT ...
2 FROM tProjet
3 WHERE nom LIKE "*" & Forms!fRecherche!nom ...
Attention : lorsque vous saisissez une valeur dans le formulaire, faites "Entrée" pour valider
avant d'exécuter la requête.
Question 3
Proposer un exemple d'exécution.
Indice :
Un exemple d'exécution dans votre cas est une illustration d'un résultat obtenu (sortie) à partir
du paramétrage (entrée). On pourra par exemple effectuer des copies d'écran.
5. Exercice : Automatisation de l'application par les macros
Question 1
Ajouter un bouton "OK" à vos formulaires d'ajout et de recherche de projet, afin d'exécuter
directement les requêtes SQL.
Indice :
59
Exercice : Automatisation de l'application par les macros
Ajouter un contrôle de type bouton de commande
N'utilisez pas les assistants ! (annuler dès qu'ils se présentent).
Question 2
Automatisez l'ouverture des formulaires avec des Macros.
Indices :
Pour créer une macro :
1. Cliquer sur Créer > Macro > Macro
2. Sélectionner les actions à effectuer
3. Paramétrer les actions dans la zone basse
60
Créer une macro
61
Éditeur une macro
En général, dès que l'on a plusieurs macros, il est conseillé de travailler avec des groupes de
macros, plutôt que des macros isolés. Pour cela activer la colonne Noms de macros.
62
Exercice : Prise en main de l'environnement VBA
Activer les options des macros
6. Exercice : Prise en main de l'environnement VBA
Créez un module "test".
Question
[ *]
Écrivez une procédure "HelloWorld()" :
- qui prend en argument une chaîne de caractères
- affiche "Hello Word" suivi de la chaîne passée en argument dans la fenêtre d'exécution
Écrivez une fonction "fHelloWorld2()" qui, en plus, retourne la valeur 0.
Indices :
Affichez la fenêtre d'exécution (CTRL+G ou menu "afficher") dans l'interface d'édition de
module VBA.
Pour exécuter une fonction tapez "? fonction(arg1, arg2)" dans la fenêtre d'exécution.
Pour exécuter une procédure, tapez simplement "proc arg1 arg2" dans la fenêtre d'exécution.
L'instruction "Debug.Print MyString" permet l'affichage dans la fenêtre d'exécution.
Le caractère de concaténation sous Access est "&".
7. Exercice : Automatisation de l'application en VBA
Question
63
Exercice : Alimentation de l'application en VBA
Automatisez l'ouverture des formulaires avec des fonctions VBA.
Indices :
1.
2.
3.
4.
Ajoutez un module VBA ihm
Écrivez les fonctions insertProjet() et rechercheProjet()
Utilisez le commande DoCmd.OpenQuery ("nom de la requête")
Ajoutez l'appel à la fonction sur la propriété "Sur clic" du bouton
Créer un module VBA
Pour appeler une fonction depuis un contrôle, écrire =nomDeLaFonction() dans la propriété
événementielle voulue du contrôle (Sur clic par exemple).
1 Function rechercheProjet()
2 DoCmd.OpenQuery ("vRecherche")
3 End Function
8. Exercice : Alimentation de l'application en VBA
Créez un module "Alimentation".
Question 1
[ *]
Créer une fonction "fAjoutSpecialite" prenant en argument une chaîne de caractère et réalisant
l'insertion dans la base de données.
Testez-la en ajoutant de nouvelles spécialités.
64
Exercice : Manipulation des données en VBA
Indice :
Inspirez vous de l'exemple du cours.
Utilisez l'instruction : CurrentDb.CreateQueryDef("", vSQL).Execute.
Question 2
[ *]
Créer un formulaire indépendant permettant d'ajouter des spécialités (le formulaire ne contient
donc qu'un seul champ).
Indices :
Le formulaire fera appel à la fonction "fAjoutSpecialite()" en lui passant en argument le contenu
du champ de saisie.
La fonction sera appelée sur la propriété "Sur Clic" du bouton "Valider" du formulaire.
Question 3
[ *]
[Cette question est optionnelle]
Ajoutez à votre fonction une gestion d'exception permettant de renvoyer 1 si l'exécution s'est bien
passé et 0 sinon.
Indice :
Inspirez vous de l'exemple du cours.
Utilisez la structure de gestion d'exception ci-après.
1 On Error GoTo ErreurInsertion
2 ...
3 Exit_ParcoursTable:
4 ...
5 Erreur_ParcoursTable:
6 ...
Question 4
[ *]
Ajoutez à votre fonction un test préliminaire permettant d'alerter l'utilisateur en cas de doublon.
Indices :
Commencez par une instruction SELECT pour vérifier que la chaîne à insérer n'existe pas déjà.
S'il la chaîne existe, alertez l'utilisateur à l'aide de l'instruction "MsgBox vMessage".
9. Exercice : Manipulation des données en VBA
Question 1
[ *]
Créer un module "Manipulation".
Écrivez deux fonctions, l'une permettant de renvoyer le nombre de spécialités actuellement
existantes et l'autre le nombre de spécialités actuellement utilisées.
65
Exercice : Manipulation des données en VBA
Affichez le résultat de ces deux fonctions dans le formulaire "fAjoutSpecialite".
Indice :
Pour afficher le résultat d'une fonction, ajouter un contrôle de type saisie de texte, avec comme
valeur "=fNomFonction()".
Question 2
Écrivez une fonction permettant de normaliser une chaîne de caractère de la façon suivante :
- La chaîne ne doit pas comporter d'espace (tout ce qui est après le premier espace est
supprimé).
- La chaîne commence par une majuscule et se poursuit par des minuscules.
Utiliser cette fonction pour normaliser la table spécialité.
Indices :
- La fonction Right(S, N) renvoie le N caractères à droites de la chaîne S (idem pour Left à
gauche).
- La fonction Len(S) renvoie la longueur de la chaîne S
- Le caractère de concaténation est le "&"
Appeler la fonction dans une instruction UPDATE.
Vous veillerez à propager les mises à jour dans les tables référençant les spécialités :
- Utilisation de la propriété ON CASCADE,
- ou bien suppression de la contrainte d'intégrité avant mise à jour, et réactivation après.
* *
*
Faire une démonstration de votre réalisation, en montrant vos schémas MCD et MLD, votre code SQL,
le résultat de son exécution dans Access (interface de création de table), votre séparation
BD/application, votre formulaire de saisie, la requête d'insertion depuis ce formulaire, le formulaire
d'interrogation, la requête de question paramétrée associée.
Décrivez le processus général de conception d'une base de données et de ses couches applicatives sous
Access, en soulignant pour chacune des étapes les aspects technologiques qui vous paraissent intéressants
ou au contraire limitants.
Appuyez-vous sur ce que vous avez réalisé pour montrer et argumenter.
66
Pratique : Initiation à Access VBA
Pratique : Initiation
à Access VBA
V
Objectifs
Apprendre à se servir de VBA pour manipuler une base de données Access
Expérimenter l'usage d'un langage de programmation pour manipuler une base de données
La première partie du TP a pour objectif l'écriture d'un programme VBA permettant de lire un
fichier SQL de façon à exécuter une série d'instructions LDD et LMD en vue de la création et de
l'initialisation d'une base de données.
Il est demandé de prendre des notes au niveau de chaque question posée, afin de garder la trace des
réalisations.
Une synthèse finale d'une ou deux pages devra être rédigée.
Une démonstration de 5 minutes devra également être faite à votre chargé de TP.
1. Exercice : Déclaration de la base de données en SQL
Vous êtes le président de l'association "Objectifs", dont l'objet est d'aider ses étudiants membres à
mener des projets dans le cadre de leurs études. Cette association est dotée d'une base de données
Access pour gérer les projets. Afin d'envisager l'amélioration de l'application, vous décidez d'en
refaire le développement en utilisant le langage de développement d'Access, le VBA.
Votre première action est de redévelopper la création de la base en se basant sur le langage SQL
plutôt que la création interactive qui a été jusque là favorisée. Cela permettra de plus facilement
modifier la base dans le cadre d'évolutions futures.
67
Exercice : Déclaration de la base de données en SQL
Modèle UML de la base de données de gestion de projets
État des projets de l'association Objectifs
La base de données n'a pour le moment été implémentée que partiellement. Le schéma relationnel
ci-dessous décrit ce qui a été traité.
1 Projet (#Num, Nom, Debut, Fin, ChefDeProjet=>Membre, Specialite=>Specialite
2 Specialite (#Intitule)
3 Membre (#Prenom, Nom, Specialite=>Specialite)
68
Exercice : Test des instructions SQL
Question 1
[ *]
Écrivez dans un fichier texte les instructions LDD permettant d'implémenter les trois tables de ce
schéma relationnel.
Indice :
Utilisez un éditeur ASCII pour écrire du code informatique (comme par exemple le logiciel libre
Notepad++). N'utilisez jamais un logiciel de traitement de texte, comme Word, qui ajoute des
caractères non standards, gère mal les tabulations, etc.
Question 2
[ *]
Écrivez dans un fichier texte les instructions LMD permettant d'initialiser la base de données avec
les données existantes.
2. Exercice : Test des instructions SQL
Afin de vérifier la validité de votre SQL et de tester le comportement d'Access, exécutez vos
requêtes SQL une par une via l'interface graphique d'Access.
Question 1
Créez une base de données "assoBdTmp.mdb". Ouvrez une nouvelle requête en mode SQL et copiez
vos instructions SQL une par une afin de les exécuter.
Indices :
Il peut arriver qu'Access bloque une instruction (pour des raisons de "sécurité"), vous pouvez la
débloquer.
69
Gérer les contrôles de sécurité d'Access
Pour écrire une requête directement en SQL, créer une requête puis choisissez le mode SQL.
70
Passer en mode SQL
71
Exécuter une requête
Pour voir les nouvelles données s'afficher dans une table déjà ouverte, après un INSERT par
exemple, utiliser le bouton Actualiser.
72
Exercice : Programme VBA d'exécution SQL
Rafraîchir les valeurs d'une table déjà ouverte.
Question 2
[ *]
Vérifiez au fur et à mesure que la base de données se construit bien conformément à vos
instructions.
Indices :
Tester les types acceptés par Access et ceux qui ne le sont pas. Par exemple
- les types VARCHAR(X) et INTEGER et DATE sont acceptés
- le type CHAR n'existe pas, mais sa déclaration est acceptée et il et est géré comme un
VARCHAR
Veillez au format des dates à l'insertion.
Vérifier les clauses SQL acceptées et celles qui ne le sont pas : Par exemple DEFAULT et
CHECK (correspondant à "Valide Si") ne sont pas acceptés (ils ne peuvent être spécifiés qu'en
mode interactif, pas en SQL).
http://cerig.efpg.inpg.fr/tutoriel/bases-de-donnees/chap18.htm
Pensez à vérifier que les contraintes d'intégrité sont bien déclarées, via la fenêtre "Relations"
(menu Outils > Relations)
73
3. Exercice : Programme VBA d'exécution SQL
Vous allez à présent écrire un programme VBA qui permettra d'enchaîner l'exécution des requêtes
SQL sans avoir à passer par l'interface graphique. En effet, vous découvrez qu'il n'est pas prévu
dans Access de créer une BD à partir d'un fichier texte contenant des instructions SQL (alors que
la plupart des SGBD proposent ce genre de fonctions).
Question 1
Créez une base de données "assoBd2.mdb". Créez un module VBA nommé "SQL". Configurez
correctement votre interface d'exécution.
Indice :
Affichez la fenêtre d'exécution (CTRL+G ou menu "afficher") dans l'interface d'édition de
module VBA.
Question 2
[ *]
Écrivez le programme VBA permettant d'enchaîner l'exécution de vos requêtes SQL.
Indices :
Afin de manipuler un fichier, il faut utiliser les instructions Open, Input et Close.
Appuyez vous sur l'exemple de code VBA du cours et sur l'aide d'Access pour avoir un exemple
de programme permettant la lecture d'un fichier. Pour cela écrivez le mot "Open" (par exemple)
et appuyez sur CTRL+F1.
74
Aide en ligne d'Access
Notez que le caractère point-virgule est l'élément séparateur entre deux requêtes.
Pour exécuter une requête LDD, utilisez l'instruction : CurrentDb.CreateQueryDef("",
vSql).Execute (avec vSQL l'instruction SQL sous forme de chaîne de caractère).
Testez votre programme à l'aide de deux instructions SQL simples, comme par exemple celles
proposées ci-dessous.
- create table t (a integer);
- insert into t values (1);
Pensez à supprimer les tables créées entre deux exécutions, sinon le moteur de la BD vous
renverra une erreur due à l'impossibilité de créer deux tables de même nom.
Vous pouvez utiliser l'instruction DROP TABLE à cette fin.
Utilisez votre programme pour lire votre (ou vos) fichiers contenant les listes d'instructions SQL et
les exécuter.
Question 3
Créez d'abord le schéma de la base de données.
Question 4
[ *]
75
Initialisez les données de la base en utilisant le même procédé.
76
Compléments
Compléments
VI
1. Pratique : Approfondissement de la création d'application sous
Access Objectifs
Approfondir l'usage d'Access
Expérimenter les concepts de SGBDR
Réaliser des applications de bases de données
Ce TP est réservé aux étudiants de NX17, il vise à approfondir l'usage d'Access, notamment dans
sa fonction de création d'applications.
Il est demandé de prendre des notes au niveau de chaque question posée, afin de garder la trace des
réalisations.
Une synthèse finale d'une ou deux pages devra être rédigée.
Une démonstration de 5 minutes devra également être faite à votre chargé de TP.
L'usage des assistants est formellement interdit (Si un assistant apparaît involontairement, annuler
et continuer manuellement).
Ce TP fait suite au premier TP sous Access, il vise à terminer la création de l'application telle que
l'avait spécifié Pierre.
1.1. Exercice : Alimentation de la BD (amélioration)
L'objectif est de compléter le formulaire d'alimentation de la base de données pour qu'il
corresponde à celui préconisé par Pierre.
Question 1
Proposer de choisir le chef de projet et la spécialité dans une liste plutôt que de le saisir en toutes
lettres (pour le chef de projet, on pourra alors afficher selon la sélection son prénom et sa spécialité).
Question 2
Ajouter l'insertion des tâches en même temps que du projet (plusieurs requêtes INSERT devront
être exécutées).
77
Exercice : Interrogation de la BD (amélioration)
Question 3
Pour les tâches, on vérifiera que les débuts et fins des tâches sont cohérents avec le projet. On
vérifiera aussi que tout projet contient au moins une tâche.
Question 4
Pour les chefs de projet et les spécialités, permettre de définir une nouvelle valeur. Une requête
INSERT complémentaire devra insérer donc préalablement insérer cette valeur dans les tables
correspondantes.
1.2. Exercice : Interrogation de la BD (amélioration)
L'objectif est de compléter le formulaire de recherche pour qu'il corresponde à celui préconisé par
Pierre. Réaliser une nouvelle vue dont la requête source est paramétrée par un second formulaire
plus élaboré, afin de rechercher les projets tels que :
-
Leur nom contient un (unique) mot clé donné.
Ils ont commencé avant une date donnée et se sont terminés après une date donnée.
Leur chef de projet est donné.
La spécialité du projet est donnée.
Chacun de ces paramètres peut ne pas être renseigné. Ces paramètres correspondent également aux
données à projeter pour le lecteur.
Question 1
Créer le formulaire de recherche fRecherche2.
Question 2
Créer la vue vRecherche2.
Indices :
Faites une recherche dans l'aide sur l'extension SQL "IIf" proposée par Access, pour tester les
cas de nullité et proposer une valeur par défaut permettant de tout sélectionner si le champ
n'est pas renseigné.
Faites une recherche dans l'aide sur l'extension SQL "IsNull" proposée par Access pour tester la
nullité d'un champ.
Faites une recherche dans l'aide sur l'extension SQL "CDate" proposée par Access, permettant
de saisir des date dans une expression SQL.
Question 3
Réaliser un état permettant de mettre en forme la vue précédente. Appelez cet état plutôt que la
requête depuis le formulaire.
78
Exercice : Automatisation de l'application (amélioration)
1.3. Exercice : Automatisation de l'application (amélioration)
Afin de terminer votre application, vous complétez votre IHM afin que l'utilisateur puisse naviguer
de formulaire en formulaire sans utiliser l'interface par défaut d'Access.
Question 1
Réaliser un menu d'accueil, initialisé à l'ouverture de la base, qui permet soit de rechercher des
projets existants, soit d'en saisir un nouveau.
Indice :
Utilisez la macro "AutoExec".
Question 2
Réaliser les boutons permettant de fermer chaque formulaire et de retourner au menu d'accueil.
79
Citez un bon et un mauvais cas d'usage d'Access.
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
Expliquer pourquoi Access est à la fois un SGBDR et un outil de création d'application. Est-ce que des
précautions particulières doivent-être prises à ce propos ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
Access peut-il être considéré comme un "vrai" SGBDR du point de vue de la création du schéma
relationnel ? Pourquoi ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
Expliquer pourquoi les objets "requête" d'Access sont en fait des vues ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
80
Stéphane Crozat (Contributions : Antoine Vincent)
..............................................................................................................................................................................
..............................................................................................................................................................................
Access peut-il être considéré comme un "vrai" SGBD du point de vue de l'interrogation des données ?
Pourquoi ?
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Qu'est ce que QBE par rapport à SQL ? Quels sont ses avantages et inconvénients ?
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
A quoi servent les formulaires ?
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Quelle est la différence entre un formulaire lié et un formulaire indépendant ?
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Quel type de formulaire faut-il préférer en général et pourquoi ?
..............................................................................................................................................................................
..............................................................................................................................................................................
81
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
A quoi servent les macros ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
Faut-il préférer l'usage des macros ou bien de code plus bas niveau ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
A quoi sert le code VBA ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
VBA peut-il être assimilé à un "vrai" langage de programmation ?
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
82
VBA complète-t-il ou bien remplace-t-il SQL lors de la réalisation d'application ?
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Que peut-on faire avec un langage comme VBA que l'on ne peut pas faire en SQL en terme de
manipulation de données ?
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Donner quelques exemples illustrant la conformité, et inversement la non-conformité, d'Access avec une
approche SQL classique.
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Synthétisez votre pratique de la réalisation d'application sous Access, en abordant des thèmes tels que les
formulaires indépendants, les requêtes paramétrées par les formulaires, les états, les macros.
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
..............................................................................................................................................................................
Apportez une vision critique de cette approche de la réalisation d'application en en soulignant les aspects
positifs et négatifs.
..............................................................................................................................................................................
..............................................................................................................................................................................
83
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
.............................................................................................................................................................................................
84
Solutions des
exercices
Exercice p. 7
> Solution n°1
5 For i = 1 To 2
6
7 Next i
10 F=vRs!result
11 End Function
2
Exercice p. 12
> Solution n°2
Une instruction QBE


85


Description de l'instruction QBE
1. Une restriction composée avec un produit est équivalent à une jointure
2. Les tables T1 et T2 ayant le même schéma, une jointure naturelle porterai sur a et b, mais aussi
sur c.
3. Une projection composée avec un produit n'est pas équivalent à une jointure
4. La proposition exprime exactement la requête QBE.
Exercice p. 16
> Solution n°3
86
7 End Function
1
fRecherche() renvoie le nombre d'occurrences de la chaîne saisie dans le formulaire fRecherchePersonnes
dans le champs pkNom de la table tPersonnes. Or pkNom est la clé primaire, donc une seule occurrence
est possible au maximum.
Exercice p. 23
> Solution n°4
6 x = vRs!a
7 vRs.MoveNext
8 x = vRs!a
10 End Function
2
Soit la description pas à pas de l'exécution du programme :
1.
2.
3.
4.
5.
6.
7.
8.
Élimination de tous les tuples de T1
Contenu de T1 : (1)
Contenu de T1 : (1) (2)
Création d'un recordset sur T1 (sans projection ni restriction), le recordset contient donc deux
tuples et à l'initialisation pointe sur le premier (1)
Affectation de la valeur de l'attribut "a" dans le premier tuple à la variable "x" (donc x=1)
Le recordset avance au second tuple (2)
Affectation de la valeur de "a" dans le second tuple à "x" (donc x=2)
La fonction retourne la valeur de "x", donc 2
87
Exercice p. 30
> Solution n°5
Modèle UML
Une classe abstraite Espèce et un héritage peuvent être envisagés.
> Solution n°6
Exercice p. 31
1 INSERT INTO tPlantes (nom, localisation, taille, famille) VALUES (Formulaires!fPlantes!nom,Formulaires!
fPlantes!localisation, Formulaires!fPlantes!taille, Formulaires!fPlantes!famille)
> Solution n°7
Exercice p. 31
1 SELECT nom
2 FROM therbivores;
> Solution n°8
Exercice p. 31
1 SELECT tplantes.nom
2 FROM tplantes, therbivores
3 WHERE therbivores.nom=tplantes.Forms!fMange!animal AND therbivores.provenance=tplantes.localisation;
> Solution n°9
Exercice p. 32
1 Sub ComptePlantes()
2 Dim req As String
88
3 Dim ret As Integer
4 req = "SELECT COUNT(*) FROM tmange WHERE tmange.herbivore='" & Forms!fNbPlantesMangees!nom
& "';"
5 Set vRs = CurrentDb.CreateQueryDef("", req).OpenRecordset
6 If vRs.RecordCount = 0 Then
7 ret = 0
8 Else
9 ret = vRs.Fields(0)
10 End If
11 MsgBox (" nombre de plantes mangées : " & ret)
12 End Sub
Exercice p. 33
> Solution n°10
Cette requête permet de sélectionner tous les découvreurs qui ont découvert des molécules stables
contenant au moins trois des atomes spécifiés dans le contrôle "Atome" du formulaire "FChoix".
Exercice p. 33
> Solution n°11
1 SELECT Découvreur, TMolécule.Molécule
2 FROM TMolécule INNER JOIN TAtome ON TMolécule.Molécule = TAtome.Molécule
3 WHERE Stable=True
4 AND Atome=[Formulaires]![FChoix]![Atome]
5 AND Nombre>2;
> Solution n°12
Exercice p. 34
La seule clé possible est (modele, num_serie).
Ce schéma est en 1NF (les attributs sont atomiques et il existe une clé ( modele, num_serie),
mais pas en 2NF (car modele est une partie de clé qui détermine des attributs non clé).
On peut également considérer que l'attribut adresse n'est pas atomique (il contient le numéro et
la rue du client), auquel cas le schéma n'est pas en 1NF.
> Solution n°13
Exercice p. 34
1 nucli → nom, prenom, adresse, cp, ville
2 modele → marque, puissance, type, bac
3 modele, num_serie → nucli, millesime, date_achat
> Solution n°14
Exercice p. 34
1 Client(#nucli:integer, nom:string, prenom:string, adresse:string, cp:string, ville:string)
2 Modele(#modele:string, marque:string, puissance:integer, type:{'electrique', 'thermique', 'manuelle'}, bac:
integer)
89
3 Tondeuse(#num_serie:string, #modele => Modele(modele), client => Client(nucli), millesime: integer,
date_achat:date)
Si adresse a été considérée comme non atomique, elle doit également être décomposée en
adresse_num:string et adresse_rue:string : Client(#nucli:integer, nom:
string, prenom:string, adresse_num:string, adresse_rue:string, cp:string,
ville:string)
Exercice p. 34
> Solution n°15
UML de la base tondeuse
> Solution n°16
Exercice p. 35
90
7 End Function
1
fRecherche() renvoie le nombre d'occurrences de la chaîne saisie dans le formulaire fRecherchePersonnes
dans le champs pkNom de la table tPersonnes. Or pkNom est la clé primaire, donc une seule occurrence
est possible au maximum.
Exercice p. 36
> Solution n°17
Une instruction QBE




91
1. Une restriction composée avec un produit est équivalent à une jointure
2. Les tables T1 et T2 ayant le même schéma, une jointure naturelle porterai sur a et b, mais aussi
sur c.
3. Une projection composée avec un produit n'est pas équivalent à une jointure
4. La proposition exprime exactement la requête QBE.
> Solution n°18
Exercice p. 36
6 x = vRs!a
7 vRs.MoveNext
8 x = vRs!a
10 End Function
2
Soit la description pas à pas de l'exécution du programme :
1.
2.
3.
4.
5.
6.
7.
8.
Élimination de tous les tuples de T1
Contenu de T1 : (1)
Contenu de T1 : (1) (2)
Création d'un recordset sur T1 (sans projection ni restriction), le recordset contient donc deux
tuples et à l'initialisation pointe sur le premier (1)
Affectation de la valeur de l'attribut "a" dans le premier tuple à la variable "x" (donc x=1)
Le recordset avance au second tuple (2)
Affectation de la valeur de "a" dans le second tuple à "x" (donc x=2)
La fonction retourne la valeur de "x", donc 2
> Solution n°19
Exercice p. 37
A quelles instructions SQL est équivalente l'instruction QBE sous Access ci-dessous :
92
Une instruction QBE

SELECT a FROM T1

INSERT INTO T2 (a)
SELECT T1.a FROM T1

INSERT INTO T2 (a)
VALUES ([formulaires]![F1]![C1]);

SELECT a FROM T1, T2
WHERE T1.a=T2.a AND T1.a=[formulaires]![F1]![C1];
93
> Solution n°20
Exercice p. 37
5 For i = 1 To 2
6
7 Next i
10 F=vRs!result
11 End Function
2
> Solution n°21
Exercice p. 63
1 Sub HelloWorld(arg1 As String)
2 Myvar = "Hello World " & arg1
3 Debug.Print (Myvar)
4 End Sub
5 Function HelloWorld2(arg1 As String) As Integer
6 Myvar = "Hello World " & arg1
7 Debug.Print (Myvar)
8 HelloWorld2 = 0
9 End Function
94
Procédure HelloWorld
Fonction HelloWorld2
Exercice p. 64
> Solution n°22
1 Function fAjoutSpecialite(pVal)
2 vSQL = "INSERT INTO tSpecialite(pk_intitule) VALUES ('" & pVal & "')"
3 CurrentDb.CreateQueryDef("", vSQL).Execute
4 fAjoutSpecialite = 1
5 End Function
95
Exercice p. 65
> Solution n°23
fAjoutSpecialite
Fichier Access de solution disponible en ligne.
[cf. assoBd2.mdb]
> Solution n°24
Exercice p. 65
2 On Error GoTo Erreur_Insertion
5 Exit_fAjoutSpecialite:
6 Debug.Print ("Nouvelle spécialité " & pVal & " insérée")
8 Exit Function
9 Erreur_Insertion:
10 Debug.Print ("Erreur : " & vSQL)
12 End Function
> Solution n°25
Exercice p. 65
2 On Error GoTo Erreur_Insertion
96
3 vSQL = "SELECT pk_intitule FROM tSpecialite WHERE pk_intitule = '" & pVal & "'"
4 Set vRs = CurrentDb.CreateQueryDef("", vSQL).OpenRecordset
5 If (vRs.RecordCount > 0) Then
6 MsgBox ("Spécialité déjà existante, insertion annulée")
7 Else
10 End If
11 Exit_fAjoutSpecialite:
12 Debug.Print ("Nouvelle spécialité " & pVal & " insérée")
14 Exit Function
15 Erreur_Insertion:
16 Debug.Print ("Erreur : " & vSQL)
18 End Function
Exercice p. 65
> Solution n°26
1 Function fSpecialiteTotal() As Integer
2 vSQL = "SELECT count(pk_intitule) AS total FROM tSpecialite"
4 fSpecialiteTotal = vRs!total
5 End Function
1 Function fSpecialiteUtil() As Integer
2 vSQL = "SELECT count(pk_intitule) AS total"
3 vSQL = vSQL & " FROM tSpecialite S INNER JOIN tProjet P"
4 vSQL = vSQL & " ON S.pk_intitule=P.fk_specialite"
6 fSpecialiteUtil = vRs!total
7 End Function
[cf. assoAppli2.mdb]
Exercice p. 69
> Solution n°27
create.sql
1 CREATE TABLE tSpecialite (
2 pk_intitule varchar(15),
3 PRIMARY KEY (pk_intitule));
4 CREATE TABLE tMembre(
5 pk_prenom varchar(15),
6 nom varchar(15),
7 fk_specialite varchar(15),
8 PRIMARY KEY (pk_prenom),
9 FOREIGN KEY (fk_specialite) REFERENCES tSpecialite (pk_intitule));
10 CREATE TABLE tProjet (
11 pk_num varchar(4),
12 nom varchar(255),
13 debut date,
97
14 fin date,
15 fk_cdp varchar(15),
16 fk_specialite varchar(15),
17 PRIMARY KEY (pk_num),
18 FOREIGN KEY (fk_specialite) REFERENCES tSpecialite (pk_intitule),
19 FOREIGN KEY (fk_cdp) REFERENCES tMembre (pk_prenom));
Exercice p. 69
> Solution n°28
insert.sql
1 INSERT INTO tSpecialite (pk_intitule) VALUES ('Sport');
2 INSERT INTO tSpecialite (pk_intitule) VALUES ('Compta');
3 INSERT INTO tMembre (pk_prenom, nom) VALUES ('Paul', 'Eau');
4 INSERT INTO tMembre (pk_prenom, nom) VALUES ('Pierre', 'Elelou');
5 INSERT INTO tMembre (pk_prenom, nom) VALUES ('Marc', 'Noflair');
6 INSERT INTO tMembre (pk_prenom, nom, fk_specialite) VALUES ('Barbara', 'Stressée', 'Sport');
7 INSERT INTO tMembre (pk_prenom, nom, fk_specialite) VALUES ('Helene', 'Deuxtrois', 'Compta');
8 INSERT INTO tProjet (pk_num, nom, debut, fk_cdp)
9 VALUES ('1', 'La nuit du picolo', '25/12/2003', 'Paul');
10 INSERT INTO tProjet (pk_num, nom, debut, fk_cdp)
11 VALUES ('2', 'L''escalade de l''Everest', '01/01/2005', 'Pierre');
12 INSERT INTO tProjet (pk_num, nom, debut, fin, fk_cdp, fk_specialite)
13 VALUES ('3', 'Tournoi de Volley Ball', '01/02/2005', '01/03/2005', 'Marc', 'Sport');
Exercice p. 73
> Solution n°29
Tables créées
98
Données insérées
[cf. assoBdTmp.mdb]
Exercice p. 74
> Solution n°30
1 Function ExecSql(pChemin As String, pFichier As String) As Integer
2 vFichier = pChemin & pFichier
3 Open vFichier For Input As #1
4 Do While Not EOF(1)
5 vNewChar = Input(1, #1)
6 If vNewChar = ";" Then
7 Debug.Print vSql
8 CurrentDb.CreateQueryDef("", vSql).Execute
9 vSql = ""
10 Else
11 vSql = vSql & vNewChar
12 End If
13 Loop
14 Close #1
15 ExecSql = 1
16 End Function
Remarque
Il serait pertinent d'ajouter une gestion d'erreur pour ce type de fonction.
> Solution n°31
Exercice p. 75
99
[cf. assoBd2.mdb]
100
Signification des abréviations
Abréviations
BD : Base de Données
LDD : Langage de Définition de Données
LMD : Langage de Manipulation de Données
QBE : Query By Example
SGBDR : Système de Gestion de Bases de Données Relationnelles
SQL : Structured Query Language
101
Webographie
Webographie
www.developpez.com, Les meilleurs cours, tutoriels et docs sur Access, http://access.developpez.
com/, consulté en 2003.
www.developpez.com, Access FAQ, http://access.developpez.com/faq/, consulté en 2003.
Hubiche Maxence, Comprendre les jointures dans Access, http://mhubiche.developpez.
com/Access/tutoJointures/, consulté en 2009.
102
Index
Index
Application
Chaîne de caractères
p. 6, 18, 21
p. 26
Contrainte
Critique
CurrentDb
p. 10
p. 5
p. 23, 24, 25
Curseur
DELETE
Domaine
p. 23, 24, 24, 25, 25, 26
p. 14
p. 9
Enumération
Fonction
Formulaire
p. 9
p. 23, 26
p. 18, 20
Formulaires
Gestion d'erreur
GROUP BY
p. 16
p. 25
p. 14
HAVING
INSERT
Intégrité référentielle
p. 14
p. 14
p. 10
Langage de programmation
LDD
Liste déroulante
p. 23
p. 7, 10, 11, 25
p. 20
LMD
Macro
Objet
p. 12, 14
p. 21
p. 23, 24
On Error
Programme
Prototypage
p. 25
p. 23
p. 5
QBE
QueryDef
Question
p. 12, 14, 14
p. 23, 24, 25, 25
p. 12
Recordset
Requête
SELECT
p. 23, 24, 24, 25, 25, 26
p. 12, 23, 24, 25, 25
p. 12
Table
Types
UPDATE
p. 7, 10
p. 9
p. 14
VBA
p. 23, 23, 23, 24, 24, 25, 25
, 25, 25, 26, 26
Vues
p. 11
103

Applications de bureau, illustration avec Access

Transcription

Documents pareils

Access VBA niveau 2

Anne Lavergne

Formation Access perfectionnement

Formulaire de contact de la mairie de Saint Pé d`Ardet

Formation Access - Bug Assistance

Access - Conception d`une base de données

localhost / localhost / reseau-empreintes.com / E74_outils | http

Annonce pour la location d`appartement

Demande d`intervention à domicile du service

PA WIDA Parent Letter A