Utilisation de Access - epsic

Etude du SGBD MS Access2000 (ver 3.0) Baudraz Norbert Décembre 1999

sur 132

UTILISATION DE MS/ACCESS

(Introduction)

(Version 3.0, 2002)

ETUDIANTS en informatique

Sous la responsabilité du professeur A. GUERID

EIVD, Yverdon-les-Bains, 1, Rte de Cheseaux

ECOLE D’INGENIEURS DU CANTON DE VAUD

DEPARTEMENT E + I


sur 132

Table des matières

INTRODUCTION A MICROSOFT ACCESS........................................................................... 4

Présentation de la base exemple ............................................................................. 6 Cahier des charges ................................................................................................... 6 Modèle conceptuel de données .............................................................................. 6 Modèle relationnel..................................................................................................... 7

CHAPITRE 1. UTILISATION (MOTEUR JET 4.0) ................................................................. 8

1.1.Présentation du moteur de base de données JET 4.0 ................................ 8

1.2. Création d'une nouvelle base de données.................................................... 9

1.3. La fenêtre "Base de données"........................................................................13

1.4. Définition des données.....................................................................................17 1.4.1. Définition de la table CLIENT.....................................................................22 1.4.2. Définition de la table AGENCE ..................................................................23 1.4.3. Définition des tables DEPOT et RETRAIT ...............................................24

1.5. Définition des relations entre les tables ......................................................26

1.6. Insertion des données ......................................................................................29 1.6.1. Insertion en mode feuille de données .......................................................29 1.6.2. Insertion à partir d'un formulaire ................................................................31 1.6.3. Importation de données depuis un fichier texte ......................................33

1.7. Consultation des données...............................................................................37 1.7.1. Interrogation en mode feuille de données................................................37 1.7.2. Interrogation à l'aide d'une requête ...........................................................39 1.7.3. Requêtes SQL ..............................................................................................44 1.7.4. Sous-feuilles de données : .........................................................................46

1.8. Conception et utilisation d'un formulaire ....................................................48 1.8.1. Formulaire instantané ..................................................................................48 1.8.2. Personnalisation d'un formulaire ...............................................................48 1.8.3. Formulaire basé sur une requête ..............................................................52

1.10. Conception et utilisation d'un état ..............................................................56 1.10.1. Création d'un état simple sur une table ..................................................56 1.10.2. Création d'un état avec regroupement sur une requête ......................59

1.11.Page d’accès aux données.............................................................................62

1.12. Création d'une petite application ................................................................67

1.13. Conclusion sur le moteur JET 4.0 et sur Access2000...........................70

CHAPITRE 2...............................................................................................................................71

ACCESS2000 ET SQL SERVER 7.0 UTILISATION DU MOTEUR MSDE.....................71

2.1 Présentation des technologies MSDE et SQL Server 7.0 .........................71 2.1.1 MSDE (Microsoft Data Engine) ...................................................................71


sur 132

2.1.2 SQL Server.....................................................................................................72

2.2 Le projet Access..................................................................................................73 2.2.1 Création d’un projet Access.........................................................................74 2.2.2 Où se situe physiquement la base de donnée ? ......................................75

2.3 Les objets de MSDE/SQL Server.....................................................................77

2.4 Définition des données......................................................................................78 2.4.1 Les types de données SQL Server ............................................................78 2.4.2 Création des tables .......................................................................................79

2.5 Le schéma de base de données......................................................................84

2.6. Insertion des données ......................................................................................88 2.6.1 Insertion des données en mode feuille de données ................................88 2.6.2 Insertion des données depuis un formulaire .............................................88 2.6.3 Importation des données depuis un fichier texte. ....................................88

2.7. Consultation des données...............................................................................93 2.7.1 Les vues..........................................................................................................93 2.7.2 Les procédures stockées .............................................................................98

2.8 Etats, Pages d’accès aux données, Création d’une petite application104

2.9 Migration d’une base de données JET vers MSDE/SQL Server ...........104

2.10 Migration d’une base de données MSDE/SQL Server vers JET.........108

2.11 Conclusion sur MSDE....................................................................................111

CHAPITRE 3. LANGAGE SQL .............................................................................................112

3.1. Introduction .......................................................................................................112

3.2. Les nouveautés de SQL JET4.0 ...................................................................112

3.3 Comparaison entre SQL JET 4.0 et ANSI-SQL ..........................................113 3.3.1 Différences principales ...............................................................................113 3.3.2. Fonctions avancées du langage SQL du moteur Jet ...........................114 3.3.3 Fonctions SQL ANSI non gérées par SQL JET....................................115

3.4. Les instructions de base................................................................................116 3.4.1. Instruction SELECT...................................................................................116 3.4.2. Instruction INSERT ....................................................................................121 3.4.3. Instruction DELETE ...................................................................................123 3.4.4. Instruction UPDATE...................................................................................124

3.5. Quelques instructions particulières de SQL JET....................................125 3.5.1. Instruction CREATE TABLE.....................................................................125 3.5.2. Instruction CREATE INDEX .....................................................................128 3.5.3. Instruction ALTER TABLE........................................................................128 3.5.4. Instruction DROP .......................................................................................129

3.6. Transact-SQL (T-SQL).....................................................................................129

3.7. Liste des mots réservés Microsoft Access SQL .....................................130


sur 132

Introduction à Microsoft Access Microsoft Access est un système de gestion de base de données relationnelles (SGBDR) entièrement conçu pour l'environnement Windows, offrant à ce titre puissance et convivialité. La version Access 2000, qui est disponible depuis le mois de mai 1999, a subi de nombreuses améliorations par rapport à la version Access97. Cette notice est une mise à jour de la notice sur Access97 disponible à l’eivd. Les notions de bases communes à Access97 et à Access2000 sont présentées en utilisant uniquement le nom Access. Les nouveautés seront présentées en spécifiant qu’elles concernent uniquement Access2000 L'interface très conviviale d'Access permet à un utilisateur débutant de créer rapidement une petite base de données, mais offre également aux spécialistes toute la puissance et la souplesse pour le développement d'applications professionnelles. De nombreux assistants permettent d'automatiser les tâches de définitions d'objets. L'utilisateur ne fait que de répondre aux questions posées pas le logiciel. Access est intégré dans la série des produits Microsoft Office conçus pour fonctionner ensemble. A ce titre, on peut très facilement importer, exporter ou lier dynamiquement de données avec des logiciels comme Word ou Excel. Le but du chapitre 1 est de permettre à un utilisateur débutant de se familiariser avec l'environnement et les possibilités de MS Access en créant une petite base de données exemple. La base de données exemple est basée sur l’utilisation du moteur de base de donnée JET 4.0, qui est le moteur traditionnel fourni avec les différentes versions de Access. Les caractéristiques de JET seront détaillées dans le chapitre 1. Le chapitre 2 présente la nouveauté la plus fondamentale de Access2000, qui est de permettre l’utilisation du moteur de base de données MSDE à la place du moteur JET. MSDE est un moteur de base de données 100% compatible avec le moteur de base de données de SQL Server 7.0. Une base de données ou une application développée en utilisant MSDE pourra être portée vers SQL Server 7.0 sans modifier une seule ligne de code de l’application. Les capacités de MSDE seront détaillées dans le chapitre 2. La notion de projet Access permet d’utiliser Access2000 comme client frontal d’une base de données SQL Server 7.0, et de manipuler celle-ci depuis l’interface de Access2000 au lieu d’utiliser l’interface de SQL Server 7.0. MSDE ne fait pas partie de la procédure d’installation standard de Office 2000 ou de Access2000, mais il figure sur le CR-ROM de ces produits. Il peut également être utilisé pour la création d’une application depuis l’environnement de développement Visual Studio 6.0.


sur 132

Le chapitre 3 présente Access SQL, qui est un sur-ensemble de la norme SQL, complété par quelques fonctionnalités supplémentaires. L’utilisation de MSDE nécessitera l’utilisation de Transact-SQL, qui est le langage SQL utilisé par SQL Server 7.0. La programmation par macros et avec Access Basic demande des connaissances plus approfondies de l'environnement et sera présenté au chapitre 4 (Ce chapitre est encore basé sur Access97). Les captures d’écran ont été effectuées avec Access2000 mais, sauf mention contraire, les manipulations sont semblables avec Access97.


sur 132

Présentation de la base exemple Cahier des charges Tout au long de cet apprentissage, nous allons utiliser un exemple concret dont le cahier des charges est le suivant : • Une banque se propose d'informatiser les transactions effectuées par ses agences. • Un client est identifié par un numéro et se caractérise par son nom, son adresse (rue,

numéro de rue, localité et npa). • Une agence est caractérisée par un numéro, un nom (exemple agence de la Gare...)

ainsi que par la localité où elle se trouve. • Les transactions considérées sont les dépôts et les retraits. Un dépôt ou un retrait est

caractérisé par un numéro, une date et un montant. • La banque gère les clients (y compris bien sûr ceux qui n'ont pas effectué de

transaction récemment). Les clients peuvent effectuer des transactions dans l'agence de leur choix.

Modèle conceptuel de données Avant de nous lancer dans la réalisation de cette application avec Access, il nous faut modéliser ces données de manière à obtenir un schéma cohérent. Remarquons ici qu'un client ou une agence peut exister indépendamment, alors que les retraits ou les dépôts ne peuvent exister que s'ils sont liés à un client et une agence. On peut facilement voir qu'il existe ici deux entités : les clients et les agences. Entre ces deux entités, on peut identifier deux associations qui sont les dépôts et les retraits que nous décidons de gérer séparément. En tenant compte des différentes propriétés des entités et des associations énoncées plus haut, on peut établir le schéma conceptuel suivant :

Fig. 1 : Schéma conceptuel de la base.


sur 132

Les cardinalités peuvent être expliquée de la manière suivante : 1) L'énoncé de notre problème précise qu'il faut gérer les clients qui n'ont pas effectué de

transaction récemment. Un client peut donc exister sans aucune transaction. Par contre, il peut évidemment effectuer plusieurs transactions dans différentes agences, d'où la cardinalité (0.N).

2) Idem, un client n'a pas besoin d'avoir un dépôt pour exister. 3) On admet le cas d'une agence (débutante) qui n'a encore effectué aucune transaction.

Elle pourra bien sûr effectuer des versements à plusieurs clients différents. 4) Idem. Modèle relationnel Notre modèle entité-association est donc terminé, il nous faut maintenant passer de ce modèle purement conceptuel à un modèle relationnel. Pour les deux associations du modèle conceptuel, les cardinalités sont de type (0,N) des deux côtés. Selon la règle n°3 (voir cours base de données), ces associations deviennent de nouvelles relations contenant une clé de chaque entité participant à l'association ainsi que toutes les propriétés de l'association. On obtient donc les quatre relations suivantes : r-CLIENT (num_cli,nom_cli,rue_cli,num_rue,loc_cli,npa_cli) r-AGENCE (num_ag,nom_ag,loc_ag,npa_ag) r-RETRAIT (num_ret,date_ret,mont_ret,num_ag,num_cli) r-DEPOT (num_dep,date_dep,mont_dep,num_ag,num_cli) Graphiquement, on peut représenter ce schéma de la manière suivante :

Fig. 2 : Schéma relationnel de la base.


sur 132

Chapitre 1. Utilisation (Moteur JET 4.0) 1.1.Présentation du moteur de base de données JET 4.0 JET, actuellement dans sa version 4.0, est le moteur de base de données traditionnel de Access. C’est un système de gestion de données stockées dans des fichiers ; les bases de données sont stockées dans un fichier unique, et les opérations de lecture et d’écriture sont gérées par la station cliente. JET supporte l’accès simultané à la base de donnée par plusieurs utilisateurs. Les bases de données JET 4.0 peuvent faire parties de solutions développées avec les produits suivants : • Microsoft Office2000 • Microsoft Access2000 • Tout les produits et langages de la suite Visual Studio 6.0 JET ne peut pas gérer des bases de données de plus de 2 Go, et le nombre d’accès simultanés à une base de données JET est limité à 255 au maximum. La sauvegarde et la distribution des bases de données JET sont aisées, car une base de données utilisant JET est constituée d’un seul fichier. Par contre, comme les transactions ne sont pas journalisées, la récupération après incident se limite à la restauration de la dernière sauvegarde. JET est également le moteur de base de données qui nécessite le moins de ressource, par rapport à MSDE ou à SQL Server. JET 4.0 offre également une bonne compatibilité amont avec les bases de données développées avec une version antérieure du moteur JET, telle que la version 3.5 fournie avec Access97. Le choix de JET s’impose pour les systèmes bureautiques qui n’évolueront pas en taille ou en nombre d’utilisateurs. JET offre une solution à faible coût, tout en garantissant une bonne compatibilité amont avec les solutions JET existantes.


sur 132

1.2. Création d'une nouvelle base de données Une base de données Access2000 est formée des 7 catégories d'objets suivantes, qui seront présentées dans ce premier chapitre : • Les tables Définition et stockage des données.

• Les requêtes Interrogation et création de vues sur les données.

• Les formulaires

Ecrans personnalisés pour la saisie, la modification et la consultation des données .

• Les états Présentation facile des données à imprimer et calculs des totaux pour des enregistrements regroupés.

• Les pages d’accès aux données Documents Web liés à la base de données Access2000, qui permettent de consulter ou de mettre à jour les informations qu’elle contient . C’est une nouveauté de la version Access2000, qui nécessite l’utilisation de la version 5.0 du navigateur Internet Explorer au minimum.

• Les macros

Automatisation des tâches répétitives.

• Les modules Procédures du langage intégré Access Basic.

Pour démarrer le programmeAccess, il existe plusieurs possibilités : • Cliquer sur l’icône Microsoft Access de la barre de menu Office si elle est installée. • Cliquer sur l’icône Access dans le menu Démarrer => Programmes => Microsoft Access

(Fig1.1a) :

Fig1.1a: démarrage d'Access depuis le menu démarrer => Programmes


sur 132

• Autrement, cliquer directement sur un raccourci vers le programme Access 2000 (Fig1.1b) :

Fig1.1b: raccourci vers Access2000

• La dernière possibilité est de cliquer sur l’icône Nouveau document Office depuis le menu

Démarrer (Fig1.1c).

Fig1.1c: Nouveau document Office dans le menu démarrer

Et pour démarrer Access, il ne reste plus qu’à cliquer sur l’icône Nouvelle base de données (Fig1.1d)

Fig1.1d : Icône Nouvelle base de données


sur 132

Avant toute chose, et afin de se prémunir contre le fameux bug de l’an 2000, on peut forcer Access2000 à utiliser des formats de date sur 4 chiffres. Cette option est sélectionnable depuis le menu Outils => Options, onglet général, utiliser le format à quatre chiffres pour les années (Fig an2000).

Fig. An2000 : Pour forcer les dates sur quatre chiffres

Au niveau de l’interface de Access2000, Microsoft a introduit des menus « dynamiques ». Seules les entrées qui sont régulièrement utilisées sont affichées en permanence. Pour afficher les entrées qui sont masquées, il suffit de cliquer sur les deux chevrons en bas de chaque menu (Fig1.2a).

Fig1.2a: menu avec les entrées non-utilisées masquées


sur 132

Toutes les entrées du menu sont alors affichées (Fig2.1b).

Fig1.2b :toutes les entrées du menu sont affichées

Au démarrage du programme, Access affiche la fenêtre de démarrage qui ne contient aucun objet. Pour créer une nouvelle base, il faut choisir le menu Fichier / Nouvelle base de données (Fig1.3).

Fig1.3 : Création d'une nouvelle base de données

Cette fenêtre permet de créer soit une nouvelle base de données, soit de faire appel à un assistant pour créer la base ou de créer un projet de base de données. La notion de projet de base de données, qui sera détaillée dans le chapitre suivant, est l’une des principales nouveautés de Access2000.


sur 132

On obtient alors la fenêtre qui va nous permettre de créer notre nouvelle base pour la gestion de notre banque. Après avoir sélectionné l'emplacement de la nouvelle base, nous allons entrer son nom (ici GESTION) (Fig1.4). Il faut savoir que toutes les définitions d'objets ainsi que les données seront stockées dans un même fichier.

Fig1.4 : Nom et emplacement de la nouvelle base

1.3. La fenêtre "Base de données" A l'ouverture d'une nouvelle base apparaît la fenêtre "Base de données" qui sera le centre de contrôle de toutes les opérations futures (Fig1.5). Elle présente dans sa partie gauche de fenêtre la liste de tous les objets de la base classés dans les 7 catégories présentées en introduction (Fig1.6).

. Fig1.5 : Fenêtre "Base de données"


sur 132

Il suffit de cliquer sur une des catégories pour obtenir la liste des objets qu'elle contient. Ici notre base ne contient évidemment aucun élément.

Fig1.6 : sélection des catégories d’objets de la base

Les trois boutons de commande dans la partie supérieure de la fenêtre vont nous permettre de créer de nouveaux objets et d'ouvrir ou de modifier des objets existants (Fig1.6).

Fig1.6b : Création, modification ou ouverture d’un objet

La fenêtre Access présente encore une barre de menu et une barre d'outils. Ces deux éléments changent selon la fenêtre utilisée. Par exemple la barre d'outils n'est pas la même dans la fenêtre "Création de formulaire" que dans la fenêtre "Base de données". Cette barre d'outils s'appelle donc "Barre d'outils / Base de données" (Fig1.7). La terminologie est importante dans Access car on y fait directement références lorsqu'on utilise les macros.

Fig1.7 : Menu et barre d'outils "Base de données"

Le menu comporte les options suivantes :

• Fichier : opérations sur les bases de données; ouvertures, fermeture, importation, exportation et impression.

• Edition : opérations Copier/Coller et définition des relations entre tables. • Affichage : affichage des différents objets, personnalisation des barres d'outils

et des options générales de présentation. • Insertion : création instantané des sept objets (Tables, Requêtes, Formulaires,

Etats, Page d’accès web, Macros, Modules). • Outils : définition des utilisateurs de la base et de leurs droits d'accès,

gestion des mots de passe. Création d’application à démarrage automatique. Macros


sur 132

• Fenêtre : arrangement des différentes fenêtres. • Aide : rubriques d'aide. Utilisez-les !

Comme expliqué au début de ce chapitre, une partie des entrées de chaque menu peut être masquée dans Access2000 en fonction de leur utilisation. Il suffit de cliquer sur le double chevron au bas du menu pour afficher toutes ses entrées. La barre d'outils est composée d'une série de boutons qui sont en fait des raccourcis des commandes les plus utilisées du menu. Pour connaître la signification de ces boutons, il suffit de placer la souris dessus et de la laisser immobile. Une bulle d'aide s'affiche alors en dessous indiquant la fonction de ce bouton. Access est un produit très complet qui comporte un grand nombre de fenêtres, de menus et de barres d'outils différentes. Nous verrons les plus importantes, mais on a parfois tendance à se perdre dans les dédales d'options et de listes de propriétés. En comparaison avec les autres produits Microsoft, la qualité de l'aide fournie avec Access est exceptionnelle. N'hésitez pas à taper la touche <F1> à n'importe quel moment pour obtenir l'aide sur l'opération en cours. Si le compagnon Office a été installé, le petit personnage suivant apparaît à l’écran (Fig1.8a) :

Fig1.8a : compagnon Office


sur 132

Ce compagnon bien sympathique (en tous cas au début) permet (en principe) de poser des questions en langage naturel à l’ordinateur (Fig1.8b) :

Fig8 Poser les questions en langage naturel

Access va analyser la question posée, et va fournir en retour une série de rubriques susceptibles de contenir la réponse à la question posée. L’analyse est basée en partie sur les mots-clé de la question, et les résultats ne sont quelquefois pas très en rapport avec la question posée. Dans le cas ou le compagnon Office, est masqué ou n’est pas installé, la fenêtre d’aide standard est utilisable (Fig1.8c) :

Fig1.8c : Fenêtre de recherche dans l’aide

Utilisez aussi la recherche par mots clés (onglet "Index" dans la fenêtre d'aide Fig1.8c), très utile pour obtenir des informations sur un sujet particulier.


sur 132

1.4. Définition des données La fenêtre "Base de données" Access2000 permet de lancer directement les trois possibilités que l’utilisateur a pour créer une table (Fig1.9).

Fig1.9 : Utilisation d'un assistant ?

Access2000 peut proposer l’aide d’un assistant pour créer la table, ou l’utilisateur peut créer lui-même la table soit en entrant directement les données (méthode a utiliser uniquement dans des cas biens précis, car toutes les données sont enregistrées dans des champs texte), soit en définissant la table en mode création. Les assistants sont en fait des experts qui aident l'utilisateur lors de la création d'objets. L'assistant table propose (Fig1.10) :

• plusieurs modèles de tables répartis en 2 domaines, Affaire et Privé. • des listes d'attributs les plus courant pour chacune des tables, que l'utilisateur peut

sélectionner indépendamment. • l’établissement automatique des liens les plus courants entre les tables, comme un

modèle Commande-Produits-Fournisseurs.

Fig1.10 : Assistant création de table


sur 132

• Comme le modèle relationnel de notre base est déjà établi, nous n'aurons pas besoin de cet assistant. Mais il peut être très utile pour un utilisateur débutant qui ne sait pas comment modéliser sa base.

• Choisir "Mode création" dans la boîte de dialogue. • Access ouvre alors la fenêtre de création de table indiquée ci-dessous(Fig1.11).

Fig1.11 : Fenêtre "Création de table"

Cette fenêtre est divisée en deux parties : • La grille : partie supérieure qui comporte les colonnes suivantes :

• Nom du champ : nom de l'attribut de la table. Access autorise les noms contenant des espaces et des caractères accentués, ce qui permet de les rendre très significatifs. En contrepartie, on sera obligé de les renommer si l'on veut exporter cette table vers un SGBD qui ne supporte pas cette possibilité.

• Type de données : en cliquant sur la droite de ce champ, la liste des types

reconnus par Access s'affiche :

Texte Texte et nombres. Un champ Texte peut contenir jusqu'à 255 caractères.

Mémo Texte et nombres plus longs, notamment des commentaires ou des explications. Un champ Mémo peut contenir jusqu'à 64 000 caractères.

Numérique Données numériques sur lesquelles vous souhaitez effectuer des calculs mathématiques.


sur 132

Date/Heure Dates et heures. Vous pouvez créer votre propre format d'affichage ou choisir un des nombreux formats disponibles.

Monétaire Valeurs monétaires. N'utilisez pas le type de données Numérique pour les valeurs monétaires car la partie décimale du résultat des calculs risquerait d'être arrondie.

Numéro Auto Nombres séquentiels automatiquement insérés par Access en commençant par 1. Le type de données NuméroAuto fournit un champ Clé primaire tout à fait approprié. Il est compatible avec le type de données Numérique lorsque la propriété Taille du champ a pour paramètre Entier long.

Oui/Non Valeur booléenne Oui/Non, Vrai/Faux, Activé/Désactivé.

Liaison OLE Objets créés dans d'autres programmes à l'aide du protocole OLE (images, sons, animations) et susceptibles d'être liés ou incorporés à une base de données Microsoft Access par l'intermédiaire d'un contrôle dans un formulaire ou un état.

Lien Hypertexte Texte ou combinaisons de texte et de nombres enregistrés sous forme de texte et utilisés comme adresse de lien hypertexte.

Assistant Liste de choix Crée un champ qui vous permet de choisir une valeur à partir d'une autre table ou d'une liste de valeurs grâce à une zone de liste ou d'une zone de liste modifiable.

• Description : commentaire sur ce champ (attribut). Ne pas omettre cette partie car ce texte est utilisé à plusieurs reprises par Access.

• Les propriétés du champ : Chaque champ possède un ensemble de propriétés qui

permettent de définir la manière dont les données doivent être enregistrées, gérées et affichées. Les propriétés paramétrables pour chaque champ varient selon le type de données sélectionné.

Il y a deux onglets pour définir ces propriétés (‘Général’ et ‘Liste de choix’). Le second est surtout utilisé lorsque les champs contiennent des valeurs qu’il faut afficher sous la forme de zone de texte, de zone de liste, de zone de liste modifiable ou de case à cocher, Pour paramétrer une propriété de champ (onglet Général) 1. La table étant affichée en mode Création, sélectionner le champ à paramétrer. 2. Dans le bas de la fenêtre, cliquer sur la propriété à paramétrer. 3. Paramétrer la propriété.

Taille du champ Longueur maximale d'un champ de type Texte ou de type Numérique.

Nouvelles valeurs Mode de génération des nombres automatiques

(incrémental ou aléatoire).


sur 132

Format Présentation des données affichées ; utilisez les formats pré-définis ou créez des formats personnalisés.

Décimales Nombre de chiffres après la virgule. Masque de saisie Formatage des caractères pour la saisie des données.

Utilisez des masques pré définis ou personnalisez-les. Légende Intitulé du champ par défaut dans un formulaire ou un

état. Valeur par défaut Valeur entrée dans le champ lors de la création des

enregistrements. Valide si Expression qui définit les règles de saisie des données. Message si erreur Message relatif à des données non valides entrées

dans un champ. Null interdit Paramètre indiquant si des données doivent être

entrées. Chaîne vide autorisée Paramètre indiquant si les chaînes de longueur nulle

sont autorisées. Indexé Index simples destinés à accélérer les recherches et le

tri. Compression unicode Access2000 supporte le jeu de caractère Unicode, qui

définit un jeux de caractère sur deux octets pour tous les langages supportés par Microsoft. Le fait d’utiliser deux octets par caractère permet de supprimer le besoin d’installer des jeux de caractères spéciaux pour les langages pictographiques tel que le japonais. Access2000 peut utiliser la compression unicode pour limiter l’augmentation de taille des bases de données contenant beaucoup de texte.

• Placer la souris dans le premier champ de la grille et entrer le nom de l'attribut. • Le passage d'un champ à l'autre s'effectue en pressant la touche [TAB], [ENTREE] ou

avec la souris. • Choisir le type de données à l'aide de la liste déroulante. • Entrer le texte de description du champ.


sur 132

Fig1.12 : Définition de la table CLIENT

Les différents boutons de la barre d’outils sont expliqués ci-dessous :

⇒ Permet de désigner comme clé primaire la ou les colonnes sélectionnées

⇒ Affiche les propriétés des index de la table.

⇒ Insère une ligne au-dessus de la ligne en cours dans la grille.

⇒ Supprime la ou les lignes sélectionnées dans la grille.

⇒ Affiche les propriétés de la table (description et règles de validations)

⇒ Assistant générateur de champs

• A l'aide du bouton "Clé primaire", désigner le champ compteur [num_cli] comme clé

primaire, ce qui aura pour effet de créer un index sans doublons sur cette colonne. C'est Access qui attribuera automatiquement les numéros de clients qui ne seront pas modifiables. Les numéros des enregistrements effacés ne sont pas récupérés.


sur 132

• A l'aide du bouton "Propriétés de la table" , entrez sa description.(Fig1.13)

Fig1.13 : Propriétés d'une table

1.4.1. Définition de la table CLIENT • Saisir la structure de la table indiquée ci-dessous (fig1.14) :

Nom Type Taille num_cli NuméroAuto (Entier long) nom_cli Texte 30 rue_cli Texte 30 num_rue Texte 6 loc_cli Texte 30 npa_cli Texte 6

Fig1.14 : Structure de la table CLIENT

• Interdire les valeurs nulles ou les chaînes vides pour le nom, la localité et le NPA. • Forcer le nom et la localité en majuscules (Format : >). • Créer un index sans doublons sur le nom (Indexé : Oui - Sans doublons)

Fig1.14b : Propriétés de la colonne [nom_cli]


sur 132

• Enregistrer la table en cliquant sur le bouton de sauvegarde • Donner le nom CLIENT (Fig1.15).

Fig1.15 : Sauvegarde d'une table

• Pour insérer des données, cliquer simplement sur le bouton

"Feuille de données" et la table vide s'affichera (voir chapitre "Insertion en mode feuille de données").

1.4.2. Définition de la table AGENCE La structure de la table agence est la suivante (Fig1.16a):

Nom Type Taille num_ag NuméroAuto (Entier

long)

nom_ag Texte 30 loc_ag Texte 30 npa_ag Texte 6

Fig1.16a : Structure de la table AGENCE

• Saisir la définition de la table selon les valeurs indiquées. • Interdire les valeurs nulles ou les chaînes vides pour le nom, la localité et le NPA. • Forcer le nom et la localité en majuscules (Format : >). • Créer un index sans doublons sur le nom (Indexé : Oui - Sans doublons) • Sauvegarder avec le nom AGENCE.


sur 132

1.4.3. Définition des tables DEPOT et RETRAIT Les définitions des deux tables sont très semblables et correspondent aux tableaux ci-dessous (Fig1.16b et c). Les deux champs de liaisons (clés étrangères des relations) ne peuvent pas être du même type que dans les tables CLIENT et AGENCE car une table ne peut contenir qu'un seul champ de type NuméroAuto. Mais le type entier long est compatible avec ce dernier. Nom Type Taille num_dep NuméroAuto (Entier long) num_cli Nombre (Entier long) num_ag Nombre (Entier long) date_dep Date/Heure 8 mont_dep Monétaire 8

Fig1.16b : Définition de la table DEPOT

Nom Type Taille num_ret NuméroAuto (Entier

long)

num_cli Nombre (Entier long) num_ag Nombre (Entier long) date_ret Date/Heure 8 mont_ret Monétaire 8

Fig1.16c : Définition de la table RETRAIT

• Saisir les définitions des champs sans oublier d'indiquer à chaque fois la description et

la légende du champ (Fig1.17).

Fig1.17 : Définition de la table DEPOT.

La première des listes ci-dessous indique les différents types numériques possibles. Pour les types entiers ou réels, il est possible d'indiquer le nombre de décimales désirées, ou d'utiliser un des formats prédéfinis et laisser la propriété "Auto".


sur 132

Pour le type Date/Heure, il est possible de choisir parmi les formats présentés dans la troisième liste. Il ne s'agit que de format d'affichage qui sont compatibles entre eux. On pourra donc très bien saisir les dates selon un format abrégé et les afficher dans un autre format (Fig1.18a, b et c).

Fig1.18a :Tailles des numériques Fig1.18b : Formats des nombres Fig1.18c : Format des dates

Access permet de définir des contraintes d'intégrité statiques dès la définition de la table. (Fig1.19a et b).Ainsi, on peut exiger que tous les montants saisis soient positifs et que les dates des transactions soient toujours inférieures ou égales à la date du jour (vérifié lors de la saisie ou de l'importation de données).

Fig1.19a : Propriété de la colonne [mont_dep] Fig1.19b :Propriété de la colonne [date_dep]

La table DEPOT et presque identique à la table RETRAIT. Il est possible de la copier, puis de la coller sous le nom de RETRAIT (Edition/Copier ou Coller) (Fig1.20).

Fig1.20 : Copier/Coller de la table DEPOT


sur 132

1.5. Définition des relations entre les tables Access permet de définir des relations permanentes entres les différentes tables d'une base de données, ceci pour deux raisons : • permettre d'effectuer automatiquement les jointures nécessaires lors de la création de

requête, même s'il ne s'agit pas d'équijointures. • appliquer une intégrité référentielle sur les données des tables liées. Pour créer les relations nécessaires à notre exemple ( ) • Cliquer sur le bouton "Relations" de la barre d'outils "Base de données" ou sélectionner

le menu Edition / Relations... Access affiche une fenêtre vide (aucune relation n'est encore définie) et une boîte de dialogue permettant d'ajouter des tables au schéma de relation(Sans illustration).

• Ajouter les 4 tables préalablement définies en les sélectionnant dans la liste une à une

et en cliquant sur le bouton "Ajouter". • Cliquer sur le bouton "Fermer". Access affiche la fenêtre "Relations" qui contient les

représentations graphiques des 4 tables(Fig1.21).

Fig1.21 : Fenêtre "Relations"

• En les faisant glisser avec la souris, disposer les tables de la même manière que sur le

schéma relationnel que nous avons établi (introduction Fig 2).


sur 132

• Cliquer sur le champ [num_cli] de la table CLIENT et, tout en maintenant la pression, le faire glisser sur le champ [num_cli] de la table DEPOT. Access affiche alors la fenêtre de propriétés de la relation (Fig1.22).

Fig1.22 : Propriétés d'une relation

• Cliquer dans la case à cocher "Appliquer l'intégrité référentielle". • Cliquer ensuite sur le bouton "Créer" pour valider la relation. Le fait d'appliquer l'intégrité référentielle indique à Access qu'il devra vérifier l'intégrité des relations lors de tout ajout ou modification des données. Par exemple, il refusera un dépôt qui fait référence à un numéro de client inexistant. Il affichera également un message d'erreur si l'on tente d'effacer la fiche d'un client lorsque des enregistrements de la table DEPOT y font référence. Deux options supplémentaires sont disponibles :

• Mettre à jour en cascade les champs correspondants : lors de la modification d'un numéro de client, Access mettra à jour automatiquement toutes les références à cet enregistrement dans la table DEPOT.

• Effacer en cascade les enregistrements correspondants : lors de la

suppression d'un client, Access effacera également toutes les lignes correspondantes de la table DEPOT.


sur 132

Nouveauté d’Access2000, le bouton Nouvelle relation permet de créer directement une relation entre deux tables, par l’intermédiaire de la fenêtre suivante (Fig1.23) :

Fig1.23 : fenêtre créer une nouvelle relation

• De la même manière, créer les 3 autres relations nécessaires à l'établissement de notre

schéma (Fig1.24).

Fig1. 24 : Définition complète du schéma de relation.

• Cliquer sur le bouton "Enregistrer" de la barre d'outils et fermer la fenêtre pour revenir à

la fenêtre "Base de données".


sur 132

1.6. Insertion des données Access fournit 4 possibilités d'insérer des données dans une table : • Insertion directe depuis la feuille de données. • Ajout de données depuis un formulaire. • Importation de données en bloc depuis un fichier texte ou HTML, une feuille de MS

Excel ou une table d'un des SGBD suivants : Access (évidemment), Lotus, Paradox, FoxPro, dBASE, Btrieve, Oracle et SQL Server (possibilité d’utiliser ODBC).

• Exécution d'une requête SQL ajout. 1.6.1. Insertion en mode feuille de données • Depuis la fenêtre "Base de données", sélectionner la table CLIENT et presser le bouton

"Ouvrir" (ou double clic sur la table CLIENT). La table passe alors en mode feuille de donnée. C'est le deuxième mode possible pour une table, le premier étant le mode création présenté plus haut, accessible directement en pressant sur le bouton "Création", tout à gauche de la barre d'outils(Fig1.25).

Fig1.25 : Barre d'outils du mode feuille de données et basculement entre le mode création et le mode feuille de données

Les options du menu et la barre d'outils sont principalement utilisées lors des interrogations de la table. Signalons tout de même le bouton "Impression" qui permet d'envoyer directement les données de la table sur imprimante. La table CLIENT est affichée sous forme tabulaire. Remarquez que les noms de colonne ne correspondent pas aux noms des champs, mais aux légendes affectées aux champs lors de la création de la table. Lorsque le curseur est positionné dans une colonne, la barre d'état (en bas de l'écran) affiche également la description du champ.

Fig1. 6 : Insertion en mode feuille de données


sur 132

Insérons les données du premier client : N° Nom Rue N° Localité NPA 1 ACHILLE Midi 4 MORGES 1110

• Placer le curseur dans le premier champ et presser la touche TAB car le champ

[N°Client] est un compteur qui sera automatiquement incrémenté par Access. L'indicateur en marge gauche de la ligne montre que l'enregistrement est en cours de modification et l'indicateur de nouvel enregistrement passe sur la ligne inférieure. • Taper le nom : ACHILLE, la rue : Midi, le numéro : 4, puis laisser les champs [Localité]

et [NPA] vides et presser la touche TAB. Access affiche alors un message d'erreur car nous avions précisé que la saisie des champs [Localité] et [NPA] était obligatoire (Fig1.27).

Fig1.27 : Vérification des règles d'intégrité

• Entrer la localité : MORGES et le numéro postal : 1110 et pressez TAB. La ligne est alors validée. Contrairement à Ingres ou à dBASE, la feuille de données est dynamique et chaque ligne est donc validée individuellement (Fig1.28).

Fig1.28 : insertion des données du nouveau client

Le signe + au début de la ligne indique la possibilité de définir une sous feuille de données dans cette table. Cette possibilité sera détaillée plus loin dans ce chapitre.


sur 132

Nous pouvons maintenant entrer les autres clients (Fig1.29) :

N° Client Nom Rue N° Rue

Localité NPA

2 ROBERTO Poste 25 LAUSANNE 1000 3 MORGAN Midi 6 SERVION 1077 4 TCHUDI Poste 12 NYON 1260 5 DUPOND Simpl

on 3 CHAVANNES 1022

6 BARTOLI Tribunal

11 CRISSIER 1023 7 DUDRAGNE Tunne

l 16 VEVEY 1800

8 DURANT Croix 19 LAUSANNE 1010 9 VAUCHER Lac 5 MONTREUX 1820 10 DECOSTERD Foret SAVIGNY 1073

Fig1.29 : Coordonnées des clients

1.6.2. Insertion à partir d'un formulaire L'avantage du mode feuille de données est d'afficher plusieurs enregistrements en même temps. Mais Access permet également de saisir les données depuis un formulaire (écran de saisie).

Presser sur le bouton "Nouvel Objet : Formulaire automatique" de la barre d'outils. Ce bouton est atteignable depuis le mode "Création" ainsi que depuis la fenêtre "Base de données". Depuis le mode "Feuille de données", il s'appelle "Nouvel Objet : Table". Fig1.30 : menu nouvel objet, formulaire instantané

Access créée automatiquement un formulaire simple dans lequel s'affiche le premier enregistrement de notre table client (Fig1.31).

Fig1.31 : formulaire instantané


sur 132

Nous pouvons entrer notre dernier client : N° Client Nom Rue N° Rue Localité NPA

11 VUADENS Mauborget 13 LAUSANNE 1000

Dans la barre d'outils "Formulaire", presser sur bouton "Nouvel enregistrements" afin de passer en mode ajout. Access affiche alors une fiche vide dans laquelle nous pouvons entrer les données. (Toujours TAB ou ENTREE pour passer d'un champ à l'autre). • Le numéro postal saisi, presser la touche ENTER pour valider la fiche et un nouvel

enregistrement vide s'affiche. • Enregistrer le formulaire avec le menu Fichier / Enregistrer le formulaire et donner le

nom "Saisie des clients". • Fermer la fenêtre CLIENT (ou menu Fichier / Fermer) pour revenir à la fenêtre "Base

de données". En pressant sur le bouton "Formulaire" de la fenêtre "Base de données", on peut voir que "Saisie des clients" se trouve dans la liste des formulaires.


sur 132

1.6.3. Importation de données depuis un fichier texte Parmi les nombreux formats de données que Access peut importer, voyons l'exemple d'un fichier texte AGENCE.TXT contenant les informations sur les agences :

"nom_ag";"loc_ag";"npa_ag" "LA MARQUISE";"MORGES";"1110" "EPARGNE";"NYON";"1260" "SUCC. OUCHY";"LAUSANNE";"1000" "AGENCE CENTRALE";"LAUSANNE";"1012" "SUCC. GARE";"LAUSANNE";"1010" "HOTEL LE LAC";"MONTREUX";"1820" "SUCC. BELLEVAUX";"LAUSANNE";"1000" "CENTRE COMMERCIAL";"MONTREUX";"1820" "LES ROSES";"YVERDON-LES-BAINS";"1400" "LA FONTAINE";"NYON";"1260"

Le fichier comporte les noms de champs sur la première ligne et les données sont séparées par des points-virgules. Il s'agit d'un fichier texte délimité. Le fichier ne comporte pas de numéro d'agence, c'est Access qui les attribuera automatiquement. • Depuis la fenêtre base de données, sélectionner le menu

Fichier / Données externes / Importer. Access affiche une fenêtre de dialogue pour sélectionner les données à importer et permet de sélectionner le type de fichier (Fig1.32).

Fig1.32: Format des données à importer

• Sélectionner le format Fichiers texte , et le fichier AGENCE.TXT depuis la boîte

"Importer" et presser le bouton "Importer".


sur 132

• La première fenêtre permet de définir que les données contenues dans le fichier texte sont délimitées (Fig1.33). Sélectionner le format "Texte (délimité)"

Fig1.33 : Format du fichier de données texte

Access demande alors des précisions sur l'opération à effectuer (Fig1.34) :

Fig1.34 : Ajouter les données importées dans la table AGENCE

Ne pas oublier de sélectionner l’option Première ligne contient les noms des champs.


sur 132

• Ajouter les enregistrements à la table AGENCE (Fig1.35).

Fig1.35 : Ajouter les données importées dans la table AGENCE

• Presser "terminer". Access démarre l'importation et indique le résultat dans la boîte suivante (Fig1.36) :

Fig1.36 : Confirmation de l'importation des données


sur 132

• De retour dans la fenêtre "Base de données", ouvrir la table AGENCE pour vérifier le résultat (Fig1.37).

On remarque que les informations des agences sont bien ajoutées à la table et que Access a complété le champ NuméroAuto [num_ag] :

Fig1.37 : Données importées (AGENCE)

La table DEPOT est à remplir de la même façon avec les données qui proviennent du fichier DEPOT.TXT (Fig1.38).

Fig1. 38 : Données importées (DEPOT)


sur 132

1.7. Consultation des données Access fournit 4 possibilités d'interroger les données de la base : • Effectuer des recherches directement depuis le mode "Feuille de données". • Création graphique d'une requête sélection. • Interrogation avec le module Access SQL • Définition d’une sous-feuille de données (nouveauté Access2000) Note :Durant cette manipulation, nous allons principalement travailler sur la table DEPOT qui contient déjà

des informations, même s'il serait plus logique de faire intervenir quelquefois les retraits 1.7.1. Interrogation en mode feuille de données Access permet d'effectuer des recherches simples sur une table directement à partir de la feuille de données. • Ouvrir la table CLIENT depuis la fenêtre "Base de données". La barre d'outils "Feuille de données" contient (entre autres) les boutons suivants :

⇒ "Ordre croissant", trie les enregistrements du champ sélectionné. ⇒ "Ordre décroissant", trie les enregistrements du champ dans l'autre sens. ⇒ "Filtrer par sélection", sélectionne la ligne courante. ⇒ "Filtrer par formulaire", affiche une liste modifiable avec les éléments du champ. ⇒ "Appliquer/ Supprimer le filtre ", permet d'appliquer le filtre préalablement défini. ⇒ "Rechercher", permet d'effectuer des recherches de valeurs dans la tables.

• Placer le curseur dans le champ sur lequel on désire effectuer une recherche, par exemple le champ [Nom].

• Cliquer sur le bouton "Rechercher". Access affiche une boîte de dialogue qui permet de spécifier la chaîne recherchée. Il est possible d'utiliser les caractères joker habituels. Recherchons les noms de client dont la troisième lettre est un "P" : • Saisir la chaîne "??P*" dans le champ Rechercher et cliquer sur "Suivant"(Fig1.39).

Fig1.39: Recherche de texte dans une colonne


sur 132

Access trouve l'enregistrement "DUPOND" dans la table tout en gardant la fenêtre de recherche active. Cliquer sur le bouton "Suivant" pour trouver les autres enregistrements correspondant au critère de recherche. • Cliquer sur "Fermer" pour revenir à la feuille de données. • Placer le curseur dans la colonne [Localité]. • Cliquer sur le bouton "Ordre croissant". Access réaffiche alors la table avec les

enregistrements triés par ordre croissant de localité (Fig1.40).

Fig1.40 : Tri des enregistrements sur la localité

Les boutons de contrôle en bas de la fenêtre permettent déplacer le curseur de la table d'un enregistrement à l'autre ou sur le premier et le dernier. • Pour supprimer ce tri, cliquer sur le bouton "Supprimer le filtre". Nous désirons maintenant afficher tous les dépôts supérieurs ou égaux à 1000.- effectués entre le 1er et le 5 novembre. • Ouvrir la table DEPOT depuis la fenêtre "Base de données". • Choisir le menu Enregistrement / Filtre / Filtre/tri avancé. Access affiche la fenêtre de définition du filtre (Fig1.41). Il s'agit en fait d'une version simplifiée de la fenêtre de définition de requêtes expliquée plus tard.

Fig1.41 : Définition d'un filtre sur une table


sur 132

• Avec la souris, faire glisser le champ [mont_dep] de la table vers la première rubrique "Champ" de la grille.

• Dans la ligne "Critère", introduire ">=1000". • Faire glisser le champ [date_dep] dans la deuxième colonne de la grille. • Introduire le critère : "entre 1.11.99 et 5.11.99". Pour des raisons de convivialité et de compatibilité avec d'autres systèmes, Access est très souple au niveau des formats des expressions. La version française comprend en plus une syntaxe traduite, tout en supportant la syntaxe anglaise. Ainsi, nous aurions pu écrire notre critère : "Between 1 novembre 1999 and 5/11/99" • Cliquer ensuite sur le bouton "Appliquer filtre". Access revient à la feuille de données en appliquant les critères définis (Fig1.42) :

Fig1.42: résultat de l'application du filtre

1.7.2. Interrogation à l'aide d'une requête Le mode feuille de données ne permet que des requêtes très simples portant sur une seule table. Par exemple, il est impossible d'afficher tous les clients ayant effectué un dépôt, car cela implique une jointure entre les tables CLIENT et DEPOT. La deuxième manière d'interroger les tables de la base de données consiste à créer une requête : • Dans la fenêtre "Base de données", cliquer sur le bouton "Requête". • Cliquer sur le bouton "Nouveau". Comme pour les tables, Access propose un assistant qui nous aidera à automatiser la création de requêtes complexes comme :

• Requête simple : effectue une requête de sélection à partir des champs sélectionnes • Analyse croisée : affichage du résultat sous forme de feuille de calcul. • Trouver les doublons dans une table. • Non correspondance : trouver les enregistrements orphelins.


sur 132

Nous allons créer une requête affichant tous les dépôts effectués contenant les noms de clients et d'agences, triés par client et par date. • Cliquer sur "mode création" Access affiche une fenêtre demandant sur quelles tables va porter la requête (Fig1.43). Il s'agit ici des tables CLIENT, DEPOT et AGENCE. • Sélectionner la table CLIENT, puis cliquer "Ajouter", ou double-clic sur CLIENT. • Idem pour DEPOT et AGENCE, puis cliquer "Fermer".

Fig1.43: Sélection des tables utilisées dans la requête

Les tables sélectionnées apparaissent sous forme graphique dans la fenêtre de création de requête. Les relations permanentes définies entre le s tables sont ajoutées automatiquement. Nous devons maintenant indiquer quels sont les champs que la requête va retourner (Fig1.44).

Fig1.44: Définition de la requête.

• Avec la souris, faire glisser le champ [num_dep] dans la grille (1ère colonne).


sur 132

• Ajouter le champ [nom_cli] de CLIENT et le champ [num_cli] de DEPOT. • Ajouter le champ [nom_ag] de AGENCE et le champ [num_ag] de DEPOT. • Terminer avec les champs [date_dep] et [mont_dep] de DEPOT. • Dans la ligne "Tri" de la colonne [nom_cli], sélectionner "Croissant". • Idem pour la colonne [date_dep]. Une fenêtre requête comporte 3 modes de fonctionnement disponibles (Fig1.45) :

⇒ Le mode "Création" ⇒ Le mode "Feuille de données" ⇒ Le mode "SQL" Fig1.45 : mode de fonctionnement des requêtes

• Cliquer sur le mode "Feuille de données". La requête est alors exécutée. Le résultat est affiché dans une feuille de réponse

(Fig1.46):

Fig46: feuille de réponse dynamique de la requête

Il est important de remarquer que nous n'avons pas eu besoin de spécifier la jointure à effectuer entre ces trois tables; non pas parce qu'il s'agit ici d'équijointures, mais parce que Access utilise le schéma de relations que nous avons établi pour déterminer la manière de lier les tables.


sur 132

• Pour sauvegarder la requête, sélectionner le menu Fichier / Sauvegarder la requête et donner le nom "Dépôts avec noms" (Fig1.47).

Fig1.47:Enregistrement de la requête

La requête définie peut être enregistrée sous la forme d’une requête normale, d’un formulaire ou d’un état. Ces éléments supplémentaires seront définis plus loin dans ce chapitre. • Fermer la requête avec le menu Fichier / Fermer. La requête "Dépôts avec noms" est alors ajoutée dans la liste de la fenêtre "Base de données". Par la suite, cet objet "Requête" pourra être utilisé comme une table (puisqu'il s'agit d'une vue). On pourra donc créer une autre requête ou un formulaire basé sur "Dépôts avec noms". Voici un autre exemple de requête qui affiche le nom des clients et la somme des dépôts qu'ils ont effectués durant le mois de novembre (Fig1.48):

Fig1.48: requête avec regroupements et critères de sélection

• Les enregistrements doivent être regroupés par noms de clients.


sur 132

• L'opération à effectuer sur les montants est la somme. Pour que la ligne opération soit disponible, il faut sélectionner opération dans le menu Affichage lorsque la requête est en mode création (Fig1.48b)

Fig1.48b: Menu affichage, opération

• La sélection se fait sur les dates dont on ne demande pas l'affichage. La feuille de

réponse à cette requête est la suivante (Fig1.49).

Fig1.49: feuille de réponse dynamique

Les deux requêtes que nous avons vues sont des requêtes sélections qui ne modifient pas les tables de la base. Citons simplement les autres types de requêtes que l'on peut créer depuis la même fenêtre (Fig1.50) :

⇒ "Sélection" ⇒ "Analyse croisée" ⇒ "Requête création de table" ⇒ "Requête mise à jour" ⇒ "Requête ajout" ⇒ "Requête suppression"

Fig1.50: types de requêtes possibles


sur 132

1.7.3. Requêtes SQL Malgré le module de création graphique des requêtes, SQL reste le langage d'interrogation de Access. Il est d'ailleurs possible de basculer dans le mode "SQL" d'une requête pour voir comment Access fait la traduction en SQL. De manière générale, Access SQL supporte la norme ANSI-SQL89 niveau 1. Cela signifie qu'il est capable de traiter des requêtes qui sont conformes à la norme. Les fonctions de base dont nous avons besoin pour cette notice, qui reste une introduction à SQL, sont toutes traitées de façon conforme à la norme ANSI. Avec le moteur JET 4.x (à partir de Access2000), le fournisseur Microsoft OLE DB met à disposition davantage de syntaxe ANSI-SQL 92. Le but est de limiter les modifications à effectuer entre une application Access et une application SQL Server, qui utilise le Transact-SQL (ou T-SQL), autre « dialecte » SQL de Microsoft. Inversement, Le moteur JET SQL possède des mots réservés qui ne sont pas gérés dans le SQL ANSI. Cette conformité partielle permet à Access de traiter des requêtes provenant, par exemple, d'un programme Visual Basic selon le même principe que le ESQL/ADA de Ingres. Il est également possible d'écrire des requêtes SQL directement dans Access. • Depuis la fenêtre "Base de données", créer une nouvelle requête vierge. • Cliquer le bouton "Fermer" de la boîte de dialogue "Ajout de table", sans ajouter aucune

table.

• Cliquer sur le bouton de mode "SQL". Access affiche alors une fenêtre texte qui permet de taper une requête SQL(Fig1.52) :

Fig1.52 : Fenêtre Requête SQL


sur 132

Cette requête affiche le nom et la localité de toutes les agence où ont eu lieu des dépôts, classés par ordre alphabétique des agences (Fig1.53) :

Fig1.53 : Feuille de réponse de la requête SQL.

Au niveau du langage SQL, Access fournit encore 3 possibilités intéressantes (Fig1.54):

Fig1.54 : Requêtes SQL spécifique.

• Union : permet de créer une requête d'union entre deux tables ou requêtes.

• SQL direct : à ne pas confondre avec le "Mode SQL", il s'agit d'un module qui permet de donner des requêtes à exécuter sur un serveur SQL.

• Définition des données : permet de créer des requêtes de définition des données comme la modification des structures ou la suppression de table.


sur 132

1.7.4. Sous-feuilles de données : Les sous-feuilles de données sont une nouveauté de Access2000. C’est un moyen de consulter les données par association, en respectant leur hiérarchie. Chaque sous-feuille présente les enregistrements (provenant d’une autre table ou d’une requête) qui ont un lien direct avec la ligne de la feuille de données principale concernée. La hiérarchie n’est pas limitée à une seule sous-feuille de données, on peut également utiliser des sous-sous (etc…)feuilles de données. Comme exemple, nous allons créer une sous-feuille de données dans la table AGENCE, pour afficher les dépôts effectués dans chaque Agence. Pour créer une sous-feuille de données, il suffit de cliquer sur le « + » qui figure dans la partie gauche de la table AGENCE Remarque : le signe « + » n’apparaît que si l’insertion d’une sous-feuille de données est possible. La fenêtre suivante permet de définir à partir de quel élément la sous-feuille de données va être créée (Fig.1.55). La source peut être soit une table, soit une requête. Sélectionner la table DEPOT, pour indiquer que la sous-feuille de données doit être définie à partir de cette table.

Fig1.55 : Source d’une sous-feuille de données


sur 132

Les Champs fils et Champs père permettent de préciser la relation entre les deux tables. Les champs correspondants sont définis automatiquement par Access2000, mais les valeurs peuvent ensuite être modifiées par l’utilisateur. Les sous-feuilles de données sont visibles directement en mode feuille de données (Fig1.56).

Fig1.56: Table avec sous-feuille de données


sur 132

1.8. Conception et utilisation d'un formulaire Pour créer notre application de gestion, nous avons besoin de formulaires personnalisés pour une saisie ou une consultation plus agréable des informations. 1.8.1. Formulaire instantané Nous avons déjà créé un formulaire très simple pour la saisie des clients. Nous allons créer le même pour les agences : • Dans la fenêtre "Base de données", se placer sur la table AGENCE et cliquer sur le

bouton "Formulaire instantané". Access crée alors automatiquement un petit formulaire de saisie.

• A l'aide de la commande Fichier / Enregistrer, sauver sous le nom [Saisie des agences].

1.8.2. Personnalisation d'un formulaire Reprenons notre formulaire de saisie des clients pour améliorer sa présentation : • Sélectionner le formulaire [Saisie des clients] dans la fenêtre "Base de données" et

cliquer sur le bouton modifier. Access ouvre le formulaire en mode création(Fig1.57). Comme pour les tables, les deux boutons à gauche de la barre d'outils permettent de basculer entre le mode création et le mode formulaire .

Fig1. 57 : Formulaire en mode création avec la boîte à outils

L'en-tête et le pied de page du formulaire sont atteignables par le menu Affichage/ En-tête/pied de page La boîte à outils est accessible depuis le menu Affichage => boîte à outils Tous les objets présents dans un formulaire (champ, zone de texte, zone de liste, etc...) sont appelés des contrôles. Chaque contrôle possède une liste de propriétés que l'on peut modifier en faisant un double-clic sur le contrôle. Pour obtenir la liste des propriétés du formulaire même, double-clic dans le carré blanc en haut à gauche de la fenêtre.


sur 132

En mode création, Access ouvre une boîte à outils flottante qui va nous permettre d'ajouter des contrôles. Certaines fonctions comme l'ajout de boutons ou de graphique peuvent faire appel à un assistant qui automatise la création du nouveau contrôle. La fonction des différents outils est présentée rapidement ci-dessous (Fig1.58). Il est bien sûr conseillé de faire appel à l'aide (rubrique "Boîte à outils") pour plus de détails.

Fig1.58 : Fonctions de la boîte à outils

Sélection des objets Intitulé

Groupe d'options Bouton d'option Zone de liste modifiable Bouton de commande

Cadre d'objet indépendant

Saut de page

Sous-formulaire/sous-état Rectangle

Assistants contrôle Zone de texte

Bouton bascule Case à cocher Zone de liste Image

Cadre d'objet dépendant

Contrôle onglet Trait Autres contrôles (ActiveX)

Ajouter un contrôle • Sélectionner le type de contrôle désiré dans la boîte à outils, puis cliquer dans le

formulaire à l'emplacement désiré. • Si le contrôle doit dépendre d'un champ. Cliquer sur le bouton "Liste des champs" Une fenêtre s'affiche avec la liste des champs de la source de contrôle du formulaire. La source de contrôle est une propriété du formulaire qui indique la table ou la requête qui va fournir les enregistrements pour le formulaire. Dans notre exemple, il s'agit de la table CLIENT. • Pour ajouter un simple champ, sélectionner "Zone de texte" dans la

boîte à outils. • Avec le nouveau curseur, sélectionner champ désiré dans la liste des champs. • Placer le nouveau contrôle dans le formulaire.


sur 132

Supprimer un contrôle • Sélectionner le contrôle avec la souris et presser la toucher DEL ou

Edition/Supprimer. • Particulièrement utile ici, mais valable pour toutes les opérations, la commande

Edition/Annuler ou le bouton "Annuler" de la barre d'outils permet d'annuler la dernière action effectuée.

Déplacer et redimensionner un contrôle • Cliquer sur le contrôle. Ce dernier est sélectionné ainsi que son étiquette

(ici "N°Client:"). • Placer la souris sur la bordure du contrôle. Le pointeur se

transforme en une petite main et il suffit de faire glisser la sélection à l'emplacement désiré. L'étiquette se déplace avec le contrôle.

• Pour déplacer l'étiquette sans le contrôle, cliquer sur la zone ombrée du coin haut-gauche de l'étiquette, le pointeur se transforme en un doigt pointé. Faire glisser l'étiquette qui est cette fois détachée du contrôle.

• Pour redimensionner un contrôle, placer le curseur en bordure sur un des petits carrés noir. Le pointeur se transforme alors en une double flèche qui permet d'étirer le contrôle.

Changer la police et l'alignement d'un contrôle

Fig1.59: Barre de menu mise en forme

• Cliquer sur le contrôle pour le sélectionner. • Les éléments nécessaires se trouvent dans la barre d'outils "Création de formulaire",

en haut de l'écran. • Sélectionner la police désirée, sa taille, et l'alignement (gauche, droite ou centré) du

texte ainsi que la mise en forme des cadres avec la barre de menu de la fig1.59. Le contrôle est automatiquement réaffiché.

Aligner plusieurs contrôles Deux commandes utiles pour le positionnement des contrôles : • Lorsque l'on change la police d'un contrôle, seul le texte à l'intérieur est modifié, mais le

cadre ne change pas automatiquement. Pour l'ajuster au texte, exécuter la commande de menu Format / Taille / Au contenu.

• Lorsqu'on déplace des contrôles, il est souvent difficile de les aligner correctement les

uns par rapport aux autres, malgré la grille. Sélectionner deux ou plusieurs contrôles à aligner en les encadrant avec la souris et exécuter la commande du menu Format/Aligner/{Gauche, Droit, Haut ...}


sur 132

Ajout de cadres • Sélectionner le bouton "Rectangle" de la boîte à outils.

• Dans le formulaire, pointer le coin supérieur gauche du cadre à dessiner et étirer ce dernier jusqu'à sa taille finale. Relâcher la souris pour terminer.

• En général, le cadre va apparaître au premier plan et masquer les contrôles placés dessous. Exécuter la commande de menu Format / Arrière-plan pour replacer les contrôles en dessus du cadre.

Ces différentes manipulations nous permettent de modifier l'aspect de notre formulaire de saisie des clients de la manière suivante (Fig1.60).

Fig1.60 : Formulaire personnalisé pour la saisie des clients

• Basculer en mode formulaire, notre écran apparaît sous sa nouvelle présentation et

nous pouvons consulter et modifier les enregistrements.

• Presser les touches TAB ou SHIFT-TAB pour passer d'un champ à l'autre. On remarque alors que le champ localité est activé avant le champ NPA.

• Pour changer l'ordre de tabulation, repasser en mode création et exécuter la commande Affichage / Ordre de tabulation (fig1.61).

Fig1.61 : Définition de l'ordre de tabulation d'un formulaire


sur 132

• Sélectionner le champ [npa_cli] avec la souris et le faire glisser en dessus du champ [loc_cli] puis presser le bouton OK.

• Sauver avec la commande Fichier / Enregistrer et fermer la fenêtre. 1.8.3. Formulaire basé sur une requête Les données sur les dépôts ne sont pas faciles à saisir car la table ne contient que des numéros qui font référence aux tables CLIENT et AGENCE. Nous allons créer un formulaire permettant une saisie beaucoup plus aisée de ces données. La méthode est basée sur deux principes : • L'utilisation d'une requête dans un formulaire. • L'utilisation de listes modifiables. Dans la fenêtre "Base de données", sélectionner la requête [Dépôts avec noms] et presser sur le bouton "Formulaire instantané". Comme nous l'avons déjà vu, Access crée un formulaire portant sur tous les champs de la requête. • Cliquer sur le champ [date_dep], puis sur le bouton propriétés (ou double-clic). • Sélectionner la rubrique "Propriétés des données" dans la fenêtre de propriétés. • Entrer l'expression "=Date()" dans la propriété "Valeur par défaut". • Entrer l'expression "<= Date()" dans la propriété "Valide si". • Entrer le texte "Pas de transaction à l'avance !" dans "Message si erreur" Ces quelques manipulations des propriétés du champ sont un petit exemple des possibilités offertes par le paramétrages des formulaires. Dans notre exemple, la date du jour s'affichera automatiquement dans le champ [date_dep] lors de l'ajout d'un nouveau dépôt (Fig1.62). Le système vérifiera ensuite que la date réellement entrée soie bien passée et affichera un message d'erreur si ce n'est pas le cas.

Fig1.62 : Formulaire instantané sur une requête, valeur par défaut et règles d'intégrités


sur 132

• Disposer ensuite les champs pour une meilleure présentation(Fig1.63) :

Fig1.63 : Nouvelle présentation

Dans sa forme actuelle (Fig1.61) chaque saisie crée un nouveau client et une nouvelle agence, ce qui n'est pas le comportement voulu. La prochaine amélioration consiste à pouvoir afficher la liste des clients avec leur localité dans une liste déroulante. De cette manière, l'utilisateur pourra sélectionner le client d'après son nom et le numéro sera complété automatiquement. • Sélectionner le contrôle [nom_cli] et le supprimer.

• Sélectionner l'outil "Zone de liste modifiable", puis le champ [nom_cli] dans la liste des champs.

• Placer le contrôle "[nom_cli] en zone de liste" à la place de l'ancien champ nom.

Si le bouton "Assistant contrôle" de la boîte à outils est actif, Access ouvre un assistant que va nous aider à créer cette liste : • Sélectionner "Remplir la liste depuis une table ou une requête", puis "Suivant >".

• Sélectionner la table CLIENT dans la liste proposée, puis "Suivant >".

Access affiche alors la liste des champs de la source de contrôle du formulaire, à savoir la requête (ou vue) [Dépôts avec noms].


sur 132

• Sélectionner les champs [nom_cli] et [loc_cli], puis "Suivant >" (Fig1.64).

Fig1.64 : Choix des champs à insérer dans la liste

• Dans la fenêtre suivante, dimensionner la largeur des colonnes d'affichage (Sans

illustation). Une zone de liste peut afficher plusieurs champs, mais n'en retourner qu'un seul. Access demande donc quelle colonne devra être liée à la liste et à quel contrôle cette valeur devra être affectée. • Sélectionner le champ [num_cli]. C'est dans ce champ que doit se retrouver

l'information retournée par la liste modifiable.

• Donner un nom au champ [nom_cli], puis "Terminer". L'assistant ayant terminé son travail, il affiche la zone de liste dans le formulaire. • Effectuer la même opération pour le nom de l'agence (champ [nom_ag]). • Sauvegarder le formulaire sous le nom [Saisie des dépôts]. • Passer en mode formulaire pour vérifier le résultat (Fig1.65).

Fig1.65 : Formulaire de saisie avec zones le liste


sur 132

• Cliquer sur le bouton "Nouvel enregistrement" pour se positionner sur un nouveau dépôt (on peut également paramétrer le formulaire pour qu'il passe directement en mode ajout).

• Le numéro de retrait est un compteur, presser la touche TAB.

• La date est automatiquement positionnée à la date du jour, ce qui est généralement le cas. Presser la touche TAB.

• Le curseur se positionne dans la zone de liste. Cliquer sur la flèche à droite pour dérouler la liste et choisir un client ou taper la première lettre pour une recherche rapide dans la liste.

• Cliquer sur le client concerné et presser la touche TAB.

Le numéro de client est alors automatiquement mis à jour puisqu'il est lié au nom par le lien crée lors de la création de la zone de liste modifiable. • Procéder de même pour l'agence, puis saisir le montant.

• Presser la touche TAB pour valider la nouvelle entrée.

La saisie des dépôts est alors grandement simplifiée par le travail sur les noms plutôt que sur les numéros. De plus, elle est plus sûr car on est certains de sélectionner des clients existants réellement dans la base. • Pour rechercher des enregistrements, Access offre les mêmes possibilités qu'en mode

"feuille de données" sur une table, à savoir le bouton "Rechercher", les boutons de tri croissant et décroissant ainsi que l'utilisation de filtres.

Cette étape termine le chapitre sur les formulaires. Les possibilités sont presque illimitées et on ne peut que recommander de consulter l'aide pour plus de renseignements.


sur 132

1.10. Conception et utilisation d'un état Les états sont des objets destinés à présenter les données en vue d'une impression. Ils peuvent également afficher des enregistrements regroupés et effectuer des totaux. Encore une fois, la meilleure méthode (pour un débutant en tout cas) consiste à travailler avec les assistants. Ils permettent d'automatiser la création de formulaires assez complexes, simplement en répondant aux questions posées. 1.10.1. Création d'un état simple sur une table Voyons comment créer un état affichant la liste des coordonnées de tous les clients : • Depuis la fenêtre "Base de données", sélectionner la rubrique "Etats" et cliquer sur le

bouton "Nouveau".

• Access demande la source de contrôle de l'état. Sélectionner la table CLIENT et l'option "Assistant Etats". Il est aussi possible de créer deux sorte d'états instantané: Tableau ou Colonne.

• L'assistant demande ensuite quels champs devront être imprimés. Choisir dans la liste proposée en respectant l'ordre désiré (Fig1.66):

Fig1.66 : Choix des champs à inclure dans l'état


sur 132

• L'écran suivant permet de sélectionner le champ qui regroupe les autres (Fig1.67). Ici nous ne voulons établir qu'une simple liste, C’est inutile.

Fig1.67 : Choix des niveaux de regroupement

• Ensuite, on définit le champ sur lequel on effectuera le tri ainsi que l'ordre (descendant

ou ascendant).

• La définition de l'état est terminée, il nous reste à sélectionner le type de présentation

désiré (Verticale, Tabulaire ou Justifié) , la mise en page (Fig1.68a) et le style de la présentation (Fig1.68b).

Fig1.68a: choix du type de présentation de l'état


sur 132

Fig1.68b: style de la présentation

• Cliquer sur "Terminer" et Access affiche directement l'aperçu avant impression

(Fig1.69).

• Cliquer sur le bouton "Zoom" (la loupe) pour voir le détail de l'état.

• Cliquer sur le bouton "Impression" pour envoyer directement les données sur l'imprimante.

Fig1.69 : Aperçu avant impression de la liste des clients

• Sauvegarder l'état sur le nom de [Liste des clients] à l'aide de la commande Fichier/Enregistrer.


sur 132

1.10.2. Création d'un état avec regroupement sur une requête Nous désirons maintenant afficher la liste de tous les dépôts effectués par les clients auprès des différentes agences, avec un total pour chaque client et un total général. Ce problème peut de nouveau être entièrement traité par un assistant. • Créer un nouvel état. • Comme nous voulons les noms des clients et des agences dans notre présentation des

données et pas seulement leurs numéros, sélectionner la requête [Dépôts avec noms] comme source de contrôle, puis "Assistant Etats".

• Sélectionner ensuite les champs [nom_cli], [nom_ag], [date_dep] et [mont_dep] à

inclure dans l'état, les numéros ne nous intéressent pas ici. • L'assistant demande ensuite sur quels champs il doit effectuer le regroupement pour les

totaux intermédiaires. Sélectionner le champ par CLIENT (Fig1.70).

Fig1.70: Sélection du champ pour le regroupement

• L'écran suivant permet de faire des sous groupe (en ajoutant le champ [nom_ag], on

effectuerait également un total par agence).


sur 132

• Lors de la prochaine étape, sélectionnez le bouton "Option de synthèse…". On peut alors donner les options de synthèse. On choisit ici la formule à utiliser avec le champ qui nous intéresse (Fig1.71).

Fig1.71 : Choix du calcul à utiliser

• Comme pour le premier état, on finit par la mise en page. En gardant les options

proposées, voici ce qu'on obtient (Fig1.72).

Fig1.72 : Aperçu avant impression de la liste des dépôts avec totaux


sur 132

L'état ainsi crée comporte malheureusement une ligne indésirable (Synthèse pour etc…). indication peut être supprimée sans autre en mode création d'état . Dans ce mode on peut modifier la présentation et les propriétés des différents contrôles. Access offre entre autres la possibilité d'inclure des graphiques ou des liens hypertexte dans un état ou d'automatiser la création d'un état de publipostage (impression sur étiquettes des adresses de clients, par exemple).


sur 132

1.11.Page d’accès aux données Autre nouveauté de Access2000, les pages d’accès aux données (DAP) ont pour but de simplifier la publication de bases de données sur Internet ou plutôt sur un Intranet d’entreprise. Il s’agit de documents web qui sont liés à une base de données Access2000, et qui permettent de lire ou de modifier les informations qu’elle contient en utilisant un navigateur Internet. A la différence des formulaires, dont les DAP sont très proches, elles ne sont pas enregistrées dans le fichier de la base de données, mais dans un fichier HTML dynamique. Elles sont destinées à être visualisées depuis Internet Explorer 5.0. Les personnes qui consultent ces pages n’ont en principe pas besoin d’avoir Access2000 installé sur leur poste, mais les DAP reposent sur les composants web Office (OWC) => une licence Office2000 sur le poste de consultation est pratiquement obligatoire. Les DAP imposent l’utilisation de IE5 car leur utilisation est basée en partie sur le standard XML (eXtensible Markup Language) pour représenter les données. Au moment ou ce paragraphe est rédigé, à ma connaissance seul IE5 est compatible avec le langage de définition de données XML, mais ce point peut rapidement évoluer. Le moyen le plus simple pour créer une page d’accès aux données est d’utiliser un assistant. Cela permet de créer automatiquement les liens ent re la DAP et la base de données, ce qui peut être relativement compliqué si le nombre de champs à publier est important. L’assistant DAP est semblable à l’assistant utilisé pour la création de formulaires dans son principe de fonctionnement. La première fenêtre permet de choisir la table (ou la requête) et les champs à publier(Fig1.73) :

Fig1.73 : sélection de la table ou requête et des champs à publier


sur 132

L’étape suivante permet de définir un niveau de regroupement sur la DAP (Fig1.74). Attention, comme précisé dans la fenêtre, l’ajout d’un niveau de regroupement autorise uniquement un accès en lecture seule à la base de donnée.

Fig1.74 : Niveau de regroupement

La fenêtre suivante permet de préciser un ordre de tri pour les champs (Fig1.75) :

Fig1.75 : Ordre de tri

Il suffit pour finir d’indiquer le titre de la page. On peut également indiquer à Access2000 d’appliquer un style prédéfini à la page générée (Fig1.76).


sur 132

Fig1.76 : Titre de la page + style

La page est ensuite affichée en mode création. L’utilisateur peut librement modifier la mise en page générée automatiquement. Le principe pour modifier la page est le même que pour les formulaires (Fig1.77a) :

Fig1.77a : page ouverte en mode création sans appliquer un style


sur 132

Par contre, la boîte à outils mise à disposition est différente de la boîte à outils formulaire. Elles contient des composants spécifiques DHTML, ainsi que certains composants Office Web, pour, par exemple, insérer un graphique sur la page (Fig1,77b). Les explications détaillées sur ces composants sortent du cadre de cette brève introduction et sont disponibles dans l’aide d’Access2000.

Fig1.77b : boîte à outils Page d’accès aux données

Access 2000 Offre également la possibilité de modifier directement le code HTML de la page. Pour cela, lorsque la page est ouverte en mode création, il faut exécuter dans le menu Affichage la commande source HTML. Cette commande ouvre l’éditeur de code source HTML. Cet éditeur est dérivé de celui du Visual Basic 6.0. L’interface est le suivant (Fig1.78) :

Fig1.78 : éditeur de code source HTML


sur 132

La figure 1.79 illustre un exemple de thème qui peut être appliqué à une DAP.

Fig1.79 : Exemple de style automatique

La page réalisée donne depuis Internet Explorer 5 le résultat visible à la Fig1.80:

Fig80 : Affichage depuis Internet Explorer 5.0


sur 132

1.12. Création d'une petite application Sans effectuer aucune programmation, Access offre la possibilité de créer un écran de menu qui nous permettra de terminer notre application de gestion. Le principe consiste créer un formulaire vierge dans lequel on insère des boutons auxquels on attribue une certaine action, comme ouvrir un formulaire ou un état. • Créer un formulaire vierge.

• Cliquer dans le coin supérieur gauche pour afficher ses propriétés.

• Sélectionner les propriétés de présentation et modifier les 6 premières comme indiqué ci-dessous (Fig1.81):

Fig1.81 : Propriétés de présentation du menu

• Entrer le titre du menu Application GESTION à l'aide du bouton "Intitulé" de la boîte à outils.

• Formater le texte et encadrer selon la présentation désirée.

• Cliquer sur l'outil "Bouton" de la boîte à outils et dessiner un rectangle dans le formulaire. L'assistant "Bouton" est alors activé.


sur 132

• Dans la boîte de dialogue, choisir "Opération sur formulaire", puis "Ouvrir un formulaire" (Fig1.82).

Fig1.82: Choix de l'action d'un bouton

• Sélectionner le nom du formulaire : [Saisie des clients]. • L'assistant propose de trouver des informations spécifiques au formulaire ou de l'ouvrir

et d'afficher tous les enregistrements (choisir cette dernière option).

• Ensuite il propose d'insérer une image ou du texte dans le bouton. Sélectionner "Texte" et entrer "Saisie des clients".

Fig1. 83 : Choix du contenu du bouton

• lors de l’étape suivante, donner un nom au bouton. Par exemple "Lancer clients".


sur 132

• Cliquer sur "Terminer" et Access affiche le bouton dans le formulaire (Fig1.84).

Fig1.84 : Création du formulaire MENU

• A l'aide du même assistant, créer les boutons suivants :

• Saisie des agences : Formulaire / Ouvrir / [Saisie des agences]. • Saisie des dépôts : Formulaire / Ouvrir / [Saisie des dépôts]. • Afficher les dépôts : Divers / Exécuter requête / [Dépôts avec noms]. • Impression clients : Etats / Aperçu / [Liste des clients]. • Impression dépôts : Etats / Aperçu / [Liste des dépôts]. • Quitter l'application : Formulaire / Fermer un formulaire.

• Enregistrer le formulaire sous le nom "MENU" et passer en mode formulaire pour

utiliser le menu (Fig1.85).

Fig1.85 : Menu de l'application GESTION


sur 132

1.13. Conclusion sur le moteur JET 4.0 et sur Access2000. Access2000, et par extension le moteur de base de données Jet 4.0, offre de nombreuses améliorations mineures par rapport à Access97. Certaines sont pratiques, comme la correction automatique des noms d’objets, qui facilite les modifications de la base de données. Les sous-feuilles de données permettent également une représentation plus claire des relations entre les enregistrements. D’autres améliorations pourraient être très utiles, mais n’apportent en fait pas grand chose. Je pense surtout aux pages d’accès aux données ; les conditions nécessaires, que sont IE 5 et une version Access2000 ou Office2000 installée sur le poste client, limitent fortement leur intérêt, même si la simplicité de la création de ces pages est impressionnante. En résumé, les améliorations apportées à JET 4 ne peuvent pas à elles seules justifier un passage de Access97 à Access2000 d’un point de vue didactique. Les améliorations du logiciel, bien qu’ intéressantes, n’offrent rien de fondamentalement nouveau par rapport à JET 3.5 et à Access97, en tout cas lors de l’utilisation depuis Access. L’utilisation de JET4.0 dans des applications réalisées avec un langage de programmation tel que Visual Basic 6 est peut-être améliorée, mais cela sort du cadre de ce chapitre. Les nouveautés les plus intéressantes de Access2000 sont présentées dans le chapitre 2.


sur 132

Chapitre 2 Access2000 et SQL Server 7.0 Utilisation

du moteur MSDE 2.1 Présentation des technologies MSDE et SQL Server 7.0 Un des principaux problèmes qui se pose pour les développeurs d’applications dans le domaine des bases de données est le choix des technologies à utiliser pour optimiser l’utilisation de la base de données dans le futur. Par exemple, les facteurs à prendre en compte sont le nombre d’utilisateurs de la base, est-ce qu’ils accèdent simultanément à la base, est-ce que la base va devoir évoluer dans le futur, etc… Microsoft propose trois moteurs de base de données, destinés à répondre à des besoins différents. Les moteurs de base de données disponibles sont JET, MSDE et SQL Server. Le moteur de base de données JET, dont l’utilisation avec Access a été présentée dans le chapitre 1, est destiné en priorité aux bases de données de taille réduite, qui ont une utilisation limitée à quelques utilisateurs simultanés au maximum, le plus souvent sur un réseau local. C’est le système idéal pour réaliser des bases de données à usage bureautique. JET 4.0 peut être utilisé soit depuis Access, soit directement dans une application réalisée avec un langage de l’environnement de développement Visual Studio 6.0 de Microsoft. Les moteurs de base de données MSDE et SQL Server 7 sont présentés dans les deux paragraphes suivants. Ils peuvent également être utilisés depuis Access2000, Entreprise Manager de SQL Server 7 ou depuis l’environnement de développement Visual Studio 6.0. 2.1.1 MSDE (Microsoft Data Engine) MSDE est un moteur de base de données entièrement compatible avec SQL Server 7.0. Il a été développé dans le but de facilité la migration d’applications Access 2000 vers SQL Server. Avant MSDE, les développeurs n’avaient pas de solution intermédiaire entre JET, qui est prévu pour des bases de données de taille relativement faible, et SQL Server, qui est capable de gérer des bases de données de taille de l’ordre de grandeur du Tera-Octets, avec un nombre d’utilisateurs simultanés pratiquement illimité. MSDE permet aux développeurs de créer leurs bases de données dès le départ dans une version compatible avec SQL Server, mais sans avoir besoin d’acquérir directement une licence SQL Server coûteuse, qui serait inexploitée. MSDE, tout en étant 100% compatible avec le moteur de base de données de SQL Server 7, ne peut pas gérer des bases de données d’une taille supérieure à 2 Go, comme pour JET. Il est également optimisé, selon Microsoft, pour supporter au maximum 5 connexions simultanées, mais des tests indépendants de Microsoft montrent que MSDE offre des performances satisfaisantes pour un nombre de connexions simultanées de l’ordre de 25 utilisateurs, et sans grande difficulté. Les tables, procédures stockées et autres objets de base de données créés avec MSDE fonctionneront sans aucune modification dans une base de données SQL Server 7.0. Si la base de données est susceptible de migrer vers SQL Server, que ce soit en raison de la taille de la


sur 132

base de données qui pourrait dépasser deux Gb, ou d’augmentation du nombre d’utilisateurs simultanés, le choix de MSDE s’impose. MSDE diffère de JET du fait que la base de données n’est pas enregistrée dans un fichier, donc MSDE n’est pas soumis aux limitations des bases de données de ce type. Dans un système de base de données serveur, tel que MSDE ou SQL Server, les requêtes sont effectuées sur le serveur. Seul le résultat des requêtes est envoyé au client. Cette méthode permet de réduire fortement le trafic réseau, et permet aux utilisateurs d’accéder aux données avec des performances acceptables, même si leur station cliente est de faible puissance. A la différence de SQL Server 7, presque aucun outil d’administration n’est fourni avec MSDE. Il peut être utilisé soit depuis Access2000, soit depuis Entreprise Manager de SQL Server 7. Point important, les bases de données MSDE fonctionnant sur les plates- formes Windows NT ou bientôt Windows 2000 sont capables d’utiliser la sécurité intégrée de ces systèmes, ce qui n’est pas le cas des bases de données JET. Au niveau du coût des licences, MSDE est disponible pour tous les possesseurs d’une licence Office2000 Professionnel, Office2000 Premium, Access2000 ou de l’un des outils de développement suivants : • Visual Studio 6.0 édition professionnelle ou entreprise • Visual Basic 6.0 édition professionnelle ou entreprise • Visual C++ 6.0 édition professionnelle ou entreprise • Visual InterDev 6.0 édition professionnelle • Visual J++ 6.0 édition professionnelle • Visual FoxPro 6.0 édition professionnelle Les développeurs de solutions bureautiques utilisant MSDE peuvent distribuer leurs solutions librement sans redevance, à condition que ces développeurs soit en possession d’une licence Office 2000 Développeur ou d’un des outils de développement de la suite Visual Studio 6.0 (voir la liste plus haut). 2.1.2 SQL Server SQL Server, actuellement disponible dans sa version 7.0, est un système de gestion de données client-serveur. Contrairement à JET et aux bases de données sur fichiers en général, le moteur SQL Server gère lui-même les opérations de lecture et d’écriture dans la base de donnée. La limite théorique de taille pour les bases de données SQL Server est de 1 Tera-octets. SQL Server 7 est capable de gérer plusieurs centaines, voir plusieurs milliers de connexions simultanées. Il est également entièrement administrable à distance, et peut utiliser soit ses propres options de sécurité au niveau utilisateur, soit les options de sécurité Windows NT/2000. Le choix de SQL Server 7 pour une base de données s’ impose quand la taille de la base de données dépasse les 2 GB, ou que le nombre de connexions simultanées à la base peut dépasser plusieurs centaines, voir plusieurs milliers. SQL Server 7 permet de garantir des bonnes performances, même en cas de charge aussi importante. MSDE ne peut en pratique pas dépasser 25 connexions simultanées, et JET a une limite théorique de 255 connexions simultanées (en pratique, la limite serait plutôt de 30).


sur 132

2.2 Le projet Access Le projet Access est un nouveau type de fichier Access, qui permet d’établir une connexion avec le moteur de base de données MSDE ou vers des bases de données SQL Server 7 (ou 6.5) en client-serveur sans passer par le moteur JET 4.0. Les caractéristiques principales des projets de données Access sont les suivantes : • Les projets Access n’utilisent pas de fichier .mdb. Access enregistre les formulaires, les états et

les autres objets d’application des bases de données dans un seul fichier composite comportant l’extension .adp.

• Le fichier .adp ne comporte pas de table ou de requête. MSDE ou SQL Server enregistre les

tables et les vues (cf. §2.3). • Les procédures stockées MSDE/SQL Server 7 remplacent les requêtes actions Access.(cf. §

2.3). • MSDE et SQL Server 7 ne proposent pas l’équivalent des champs de référence ou des fonctions

de sous-feuille de données de JET. Ces possibilités sont perdues lors de la migration vers un projet de données Access client-serveur.

• Les projets Access se passent de JET, d’ODBC et des DAO (Data Access Objects), en

substituant les fournisseurs de données OLE DB et les objets de données ActiveX à la connectivité des bases de données et aux manipulations de données. OLE DB est la nouvelle méthode utilisée par Microsoft pour pratiquement tout ce qui concerne l’accès aux données.

Les projets de données Access sont très adaptés pour les types d’applications Access2000 suivantes : • Les applications interface de bases de données, nouvelles ou existantes, concernant des

bases de données SQL Server 6.5 ou 7.0. Access2000 intègre un concepteur graphique pour accéder aux bases de données SQL Server et MSDE, ou pour créer de nouvelles bases. Ce concepteur utilise OLE DB, ce qui signifie qu’il serait capable de fonctionner avec d’autres bases de données compatibles OLE DB, telle que Oracle. En pratique, l’utilisation se fait surtout avec SQL Server 7.

• Les applications qui sont susceptibles d’évoluer vers SQL Server 7 dans un avenir proche,

ou même à moyen terme. Les bases de données basées sur MSDE peuvent évoluer sans aucune modification vers SQL Server 7.


sur 132

• Les projets utilisant la réplication SQL Server 7 bi-directionnelle plutôt que la réplication Access vers SQL Server 7.0. La réplication SQL Server est beaucoup plus robuste que la réplication Access. La réplication entre MSDE et SQL Server suppose une réplication SQL Server par poste.

Si le projet Access est connecté à une base de données SQL Server, l’utilisateur soit disposer d’une licence client requise pour SQL Server. 2.2.1 Création d’un projet Access La création d’un projet Access se fait de manière pratiquement identique à celle d’une base de données JET. La fenêtre nouveau permet de créer ce projet en sélectionnant l’icône Projet(Nouvelle base de données, puis en cliquant sur le bouton Nouveau (Fig2.1).

Fig2.1 Création d’un projet Access

L’icône Projet(base de données existante) (Fig2.1b) permet de définir un projet sur une base de données déjà existante. Le cas se présente lorsque l’on veut par exemple pouvoir travailler sur une base hébergée par un serveur SQL Server 7 depuis un poste équipé seulement d’Access2000.

Fig2.1b :projet sur une base de données déjà existante


sur 132

2.2.2 Où se situe physiquement la base de donnée ? L’emplacement physique des informations de la base de données peut être défini de différentes manières. La fenêtre suivante (Fig2.2) permet de définir sur quel serveur SQL la base de donnée doit être créée. Point Important, la machine peut être soit un serveur avec SQL Server 7.0 installé, soit une machine où le moteur de base de données MSDE a été installé.

Fig2.2 : Choix du serveur SQL pour hébergé la base de données

Dans ce cas, la base sera créée sur le serveur SQL Server 7.0 installé sur EINEV_NT11. Mais la manipulation serait parfaitement identique pour créer une base de données sur une machine où est installé MSDE. Si MSDE est installé sur votre poste de travail, vous pouvez indiquer (local) comme serveur SQL. L’assistant est ensuite prêt pour créer la base de données (Fig2.3) :

Fig2.3 : L'assistant est prêt à créer la base de données


sur 132

La base de données est ensuite créée. La fenêtre de base de données est affichée à l’écran, et on peut commencer à définir les divers éléments de la base (Fig2.4).

Fig2.4 :Fenêtre base de données du projet Projet_Banque_utilisation

Cette fenêtre présente quelques différences par rapport à la fenêtre de base de données JET, comme détaillée dans le chapitre 1. Les différences sont surtout au niveau de la terminologie employée. Elle est détaillée dans le paragraphe suivant. Depuis Entreprise Manager de SQL Server 7.0, on peut constater que la base de données correspondante a effectivement été crée sur le serveur EINEV_NT11 (Fig2.5) :

Fig2.5 :Base de données créée dans SQL Server 7


sur 132

2.3 Les objets de MSDE/SQL Server

Fig2.6 :Objets du projet de base de données

La terminologie employée dans SQL Server 7 et dans MSDE diffère de la terminologie habituelle d’Access. Les principales différences sont détaillées ci-dessous : • Une Vue est en fait l’équivalent d’une requête sélection dans Access2000. C’est une définition

statique qui permet de créer une table dynamique à partir d’un ou plusieurs ensembles de lignes réunies selon des critères de sélection prédéfinis. Techniquement, une vue est la définition stockée d’une instruction SELECT. Comme dans les requêtes Access, le résultat de la vue est généré dynamiquement à chaque exécution de celle-ci. Le résultat est retourné sous la forme d’une table, et il peut être exploité comme une table dans une autre vue, mais c’est uniquement la vue qui est stockée dans la base de données. On ne peut pas appliquer d’ordre de tri a une vue, et on ne peut pas y passer de paramètres.

• Les procédures stockées sont un moyen de créer des routines et des procédures qui seront exécutées sur le serveur. Ces procédures, qui sont des scripts Transact-SQL pré-compilés, peuvent être démarrées par une application qui les appelle, ou être appelées par des déclencheurs ou des règles de contrôle d’intégrité des données. Les procédures stockées peuvent être employées pour retourner des valeurs ou pour en modifier. Elles offrent de bonnes performances car elles sont stockées et exécutées sur le serveur.

• Les schémas de base de données jouent le même rôle que la fenêtre Relations d’Access, mais

la présentation est différente. Les autres objets Access sont identiques, à quelques exceptions près, aux objets correspondants de l’application JET. Les différences se limitent à quelques modifications dans les propriétés des formulaires ou des états. Elles ne sont pas détaillées dans cette notice. La principale différence entre les structures de fichiers d’une base de données Access2000 JET et d’un projet de données Access2000 est que Access2000 stocke tous les objets d’application (formulaires, états, pages, macros et modules) dans un fichier composite unique appelé Docfile. Une application Access JET stocke le ficher Docfile dans le fichier .mdb, tandis qu’un projet de données Access stocke directement son fichier Docfile sur le disque dur, sous la forme d’un fichier avec l’extension .adp.


sur 132

2.4 Définition des données 2.4.1 Les types de données SQL Server Comme SQL Server et MSDE proposent de nombreux types de données, je me limite à présenter les plus courants, qui sont utilisés dans la base de données BANQUE. Pour les autres types, l’aide de Access2000 ou de SQL Server peut fournir toutes les informations nécessaires. Types numériques entiers : • INT ou INTEGER : type d’entier de base : il peut stocker des nombres entiers compris entre –

231 et 231. Chaque valeur est stockée sur 32 bits, un bit de signe et 31 bits pour indiquer la valeur.

• SMALLINT : Nombres entiers signés stockés sur 16 bits. Types numériques en virgule flottante : • REAL : nombres décimaux positifs ou négatifs avec une précision de 7 chiffres, compris entre

3,4E-38 et 3,4E38, et stockés sur 32 bits. • FLOAT : nombres décimaux positifs ou négatifs avec une précision jusqu’à 15 chiffres,

compris entre 1,7E-308 et 1,7E308, et stockés sur 64 bits. • Type DECIMAL ou NUMERIC :stockage exact des nombres décimaux, sous la forme d’une

mantisse et d’un argument. Types de données caractères : • Type CHAR : les caractères de ce type sont stockés sur un octet. Le nombre indiqué entre

parenthèses après le type indique le nombre de caractères que la structure contient par ligne, par exemple CHAR(30). Un type CHAR(n) peut contenir au maximum 8000 caractères par ligne. SQL Server rajoute automatiquement les caractères d’espacement nécessaires pour qu’une valeur de colonne ait la taille spécifiée.

• Type NCHAR : type identique à CHAR, mis à part que la taille maximale est de 4000

caractères Unicode. • Type VARCHAR : type capable de stocker une chaîne de longueur variable, au maximum de

8000 caractères. A la différence de CHAR, l’espace de stockage varie en fonction de la longueur de la chaîne de caractères.

• Type NVARCHAR : idem à VARCHAR, mais sur 4000 caractères au maximum.


sur 132

Types de données Dates et heure • Type DATETIME : stockage des dates sur 8 bytes, du 1/11/1753 au 31/12/9999, avec une

précision de 1/300ème de seconde. Point qui a son importance, le système des dates pivots est utilisé pour savoir comment gérer les années stockées sur deux chiffres : si le siècle n’est pas précisé, les années inférieurs à 50 sont associées au nombre 20 (49 => année 2049) et celles supérieures ou égales à 50 seront associées au nombre 19 (99 => 1999).

• Type SMALLDATETIME : stockage des dates sur 4 bytes, du 1/11/1900 au 6/6/2079, avec une précision d’une minute.

Types de données TEXT et IMAGE • Type TEXT : ce type est destiné à stocker de grandes quantités de textes. Il accepte jusqu’à 231

bytes de données. Pour éviter d’utiliser inutilement de l’espace disque, seul une partie de celui-ci est alloué depuis le début. L’espace restant est alloué par la suite de manière dynamique.

• Type IMAGE : ce type sert à stocker des ensembles de bits de taille variable, pouvant atteindre

également 231 bytes au maximum. Comme pour le type TEXT, l’espace disque est alloué dynamiquement, en fonction des besoins.

Types monétaires • Type MONEY : enregistrement des valeurs monétaires stockées en utilisant une partie entière

et une partie fractionnaire, au moyen de deux entiers de 4 octets. • Type SMALLMONEY : identique au type MONEY, mais sur un intervalle de valeurs réduit. 2.4.2 Création des tables Dans un projet Access, l’assistant de création de table n’existe pas. Seule la définition d’une table en mode création est possible. Dans la fenêtre base de donnée, il faut donc cliquer sur l’icône Créer une table en mode création. La première opération consiste à indiquer le nom de la table que vous voulez créer. Nous allons commencer par créer la table CLIENT.


sur 132

Ensuite, la fenêtre de création de table apparaît. Elle diffère radicalement de la fenêtre de création de table traditionnelle d’une base de données JET (fig2.7) :

Fig2.7 : fenêtre création de table d’un projet Access

Comparaison entre les colonnes de la fenêtre création de table d’un projet Access2000 et d’une base de données JET Nom de la colonne Correspondance avec JET Nom de la colonne Identique au champs du même nom dans JET,

sauf que les espaces et les ponctuations sont interdits.

Type de données Identique à la combinaison de type de données JET et de taille de champs, à l’exception de l’emploi des types de données SQL Server.

Longueur Identique au champ taille de jet pour les champs texte, sauf que les colonnes char sont de longueur fixe.

Précision Applicable au départ aux champs numériques ou décimaux. Spécifie le nombre total de chiffres de la colonne. (la précision des champs entier et monétaire est fixe)

Echelle Applicable aux champs numériques ou décimaux. Spécifie le nombre total de chiffres placés à droite du séparateur décimal (l’échelle des champs monétaires est fixée à 4).

Null autorisé Inverse de la propriété Null interdit de JET. Une coche (placée par défaut) autorise les valeurs Null dans les champs.

Valeur par défaut Identique à la propriété du même nom de JET

Compteur Equivalent au type de données NuméroAuto de JET,

avec incrément comme propriété New Value. Une coche spécifie qu’un champ Int (identique à un champ entier long de JET) crée automatiquement une nouvelle valeur lors de l’ajout d’un enregistrement.

Début du compteur Détermine la valeur de départ d’un champ compteur Incrément du compteur Détermine l’incrément entre les valeurs de compteurs

successives (par défaut 1) Est de type RowGuid Une coche indique que la ligne contient un

identificateur unique global (Guid = Global unique ID) utilisé au départ avec des champs Timestamp pour les réplications.

2.4.2.1 Structure de la table CLIENT Nous allons définir la structure de la table CLIENT de la manière suivante (Fig2.8) :


sur 132

Nom Type Taille num_cli Smallint nom_cli char 30 rue_cli char 30 num_rue char 6 loc_cli char 30 npa_cli char 6

Fig2.8a : Structure de la table CLIENT

• Déclarer le champ num_cli comme un compteur, incrément de 1. • Autoriser les valeurs nulles ou les chaînes vides pour la rue et le numéro de rue.

Fig2.8b: Structure de la table CLIENT

Comme dans une base de données JET, sélectionner la ligne num_cli avec le bouton droit de la souris, et définir cette ligne comme clé primaire de la table.

2.4.2.2 : Structure de la table AGENCE : La structure de la table agence est la suivante :

Nom Type Taille num_ag Smallint nom_ag Char 30 Loc_ag Char 30 npa_ag Char 6

Fig2.9a : Structure de la table AGENCE

Fig2.9b: Structure de la table AGENCE

2.4.2.2 : Structure des tables DEPOT et RETRAIT : Les définitions des deux tables sont très semblables et correspondent aux tableaux ci-dessous.


sur 132

Il suffit de définir la table DEPOT, puis de copier sa structure dans la table RETRAIT. La procédure est semblable à celle utilisée dans le cas de la base de données JET.

Nom Type Taille Num_dep Smallint Num_cli Smallint Num_ag Smallint date_dep Smalldatetime 8 mont_dep Money 8

Fig2.10a : Définition de la table DEPOT

Nom Type Num_dep Smallint Num_cli Smallint Num_ag Smallint date_dep Smalldatetime mont_dep Money

Fig2.10b : Définition de la table RETRAIT

MSDE ou SQL Server permettent de définir des contraintes d'intégrité statiques dès la définition de la table. Ainsi, on peut exiger que tous les montants saisis soient positifs et que les dates des transactions soient toujours inférieures ou égales à la date du jour (vérifié lors de la saisie ou de l'importation de données). Pour définir ces contraintes, il faut sélectionner la ligne concernée avec le bouton droit de la souris, puis aller sur propriétés. La fenêtre suivante apparaît (Fig2.11) :

Fig2.11: définition des contraintes d'intégrités

Nous allons donc déterminer que le montant d’un retrait ne peut pas être négatif. Dans la partie Contraintes CHECK pour la table et les colonnes, il faut cliquer sur le bouton Nouvelle, puis saisir l’expression (mont_ret >= 0) dans l’emplacement Expression contrainte (Fig2.12).


sur 132

Les contraintes sont également à définir pour la table DEPOT : pas de dépôt négatif ou en avance.

Fig2.12a: définition de la contrainte montant >=0

Et ensuite, répéter la même opération pour définir la contrainte (Date_ret <= Date()) (Fig2.12b).

Fig2.12b: Pas de retrait en avance


sur 132

2.5 Le schéma de base de données La définition des relations entre les tables diffère fortement de celle d’une base JET, telle que détaillée dans le chapitre 1. Une nouvelle catégorie d’objets apparaît dans la partie gauche de la fenêtre base de données(Fig2.13) :L’objet Schémas de base de données. Nous allons créer un schéma de base de données à l’aide du générateur.

Fig2.13 : Création du schéma de base de données

Une fenêtre vide apparaît ensuite, le générateur de schémas de base de données (Fig2.14) :

Fig2.14 : générateur de schémas de base de données


sur 132

Il faut ensuite ajouter les tables de la base de données sur le schéma. C’est possible en cliquant sur le bouton ajouter une table. Cette opération est également accessible depuis le menu contextuel. Il suffit de cliquer sur une partie libre du schéma de base de données, et le menu suivant apparaît (Fig2.15).

Fig2.15 menu contextuel du générateur de schéma de base de données

Une fenêtre apparaît ensuite, qui permet d’ajouter les tables dans le schéma (Fig2.16)

Fig2.16 fenêtre Ajouter une table dans le schéma de base de données


sur 132

Pour ajouter une table, il faut la sélectionner dans la fenêtre Ajouter une table puis, sans relâcher le bouton de la souris, la glisser sur le schéma de base de données. La Fig2.17 montre les quatre tables ajoutées dans le schéma de base de données avant que les relations soient définies.

Fig2.17 Tables ajoutées sur le schéma de base de données

Comme pour JET, les relations sont définies à l’aide de la souris, en sélectionnant par exemple le champ num_cli dans la table CLIENTS, et en le faisant glisser, tout en gardant le bouton gauche de la souris enfoncé, vers le champ num_cli de la table DEPOTS. Ensuite, dès que le bouton de la souris est relâché, la fenêtre suivante apparaît(Fig2.18) :

Fig2.18 Définition des propriétés de la relation

Cette fenêtre permet de définir la relation entre deux tables. Les relations à définir sont identiques à celles définies pour la base de données JET, présentées au paragraphe 1.6 du chapitre 1.


sur 132

Après la définition de toutes les relations, le schéma de base de données se présente comme ci-dessous (Fig2.19) :

Fig2.19 : Schéma de base de données complet

Il suffit ensuite d’enregistrer le schéma de base de données pour que celui-ci fasse partie de la base de données, au même titre qu’une table ou qu’une requête (Fig2.20) :

Fig2.20 : Le Schéma de la base de données fait partie intégrante de celle -ci


sur 132

2.6. Insertion des données MSDE et SQL Server 7 fournissent 3 possibilités communes pour ajouter des données dans une table : • Insertion directe depuis la table en mode feuille de données. • Importation depuis une source de données externe (fichier texte, autre base de données). • Exécution d’une requête SQL ajout. MSDE permet également d’ajouter des données depuis un formulaire, créé depuis Access2000. SQL Server 7 n’offre pas cette possibilité. Remarque : Dans tous les paragraphes suivants, les données utilisées sont identiques à celles employées dans le chapitre 1. 2.6.1 Insertion des données en mode feuille de données Cette méthode ne présente aucune différence importante avec une base de données JET. Elle ne sera pas plus détaillée ici. 2.6.2 Insertion des données depuis un formulaire Access2000 permet également de créer un formulaire pour une base de données MSDE. Seule différence, les formulaires instantanés ne sont pas disponibles, il faut créer les formulaires soit en utilisant un assistant, qui est identique à celui de JET, soit directement en mode création. 2.6.3 Importation des données depuis un fichier texte. L’importation des données depuis un autre fichier présente des différences importantes avec une base de données JET. Bien que l’option Données externes existe toujours dans le menu Fichiers , il vaut mieux utiliser l’assistant d’importation des données. Pour SQL Server, cet assistant est disponible directement depuis le menu Démarrer, programmes, Microsoft SQL Server 7.0, Import and Export Data (Fig2.21)

Fig2.21: assistant d'importation des données.

Pour MSDE, le même assistant est disponible depuis le menu Démarrer, programmes, MSDE (sans illustration). L’assistant d’importation des données DTS (Data Transformation Services ) est alors démarré (Fig2.22).


sur 132

Fig2.22: assistant d'importation des données

L’étape suivante consiste à définir la source de données à utiliser (Fig2.23). Dans notre cas, nous allons reprendre le fichier AGENCE.TXT déjà utilisé dans la base de données JET. Pour faciliter la manipulation, les n° d’agences ont été ajoutés dans le fichier.

Fig2.23 : définition de la source de donnée

L’assistant supporte un nombre important de formats de données: Dbase, Informix, Access, Excel, Oracle, ODBC, etc.


sur 132

Dans la fenêtre qui suit, spécifier ensuite le format du fichier texte (Fig2.24), selon le même principe que pour JET :

Fig2.24 : Format du fichier texte

La prochaine étape consiste à indiquer les délimiteurs, ici les points-virgules (fig2.25) :

Fig2.25 : délimiteurs


sur 132

Après cela, définir la destination des données, c’est-à-dire le serveur de destination et la base de données cible (Fig2.26) :

Fig2.26 : destination des données

Dans la fenêtre suivante, sélectionner la table de destination (Fig2.27) :

Fig2.27: table de destination


sur 132

Le bouton transform permet de définir l’ordre d’importation des colonnes du fichier texte dans la base de données cible. La fenêtre suivante s’ouvre (Fig2.28)

Fig2.28: Mapping des colonnes entre la source et la destination

La dernière étape permet de définir quand la transformation doit être effectuée (Fig2.29). L’importation peut en effet ne pas être effectuée immédiatement.

Fig2.29 : sauvegarde et planification de l’importation

La définition est ensuite terminée. L’importation est effectuée en cliquant sur le bouton Terminer de l’écran suivant (sans illustration). L’assistant effectue l’importation des données, puis confirme la réussite ou l’échec de l’importation par une fenêtre à l’écran (sans illustration).


sur 132

2.7. Consultation des données 2.7.1 Les vues Comme expliqué précédemment, une vue est en fait l’équivalent d’une requête sélection dans Access2000. C’est une définition statique qui permet de créer une table dynamique à partir d’un ou plusieurs ensembles de lignes réunies selon des critères de sélection prédéfinis. Pour créer une vue, il faut cliquer sur l’objet Vues dans la fenêtre base de données, puis cliquer sur . Le générateur de vue est alors affiché (Fig2.30) :

Fig2.30:générateur de vue

La structure du générateur de vue correspond au concepteur de requête Access. Son utilisation est relativement semblable. La fenêtre du générateur peut se composer de trois parties. La partie supérieure permet la conception graphique des vues. La grille intermédiaire permet d’afficher les champs qui ont été sélectionnés dans la partie graphique, et la partie inférieure permet d’afficher le code SQL de la vue. Nous allons créer une vue qui affiche tous les dépôts effectués avec les noms des clients et les agences. A la différence des requêtes dans Access JET, les vues ne permettent pas de trier les résultats obtenus. La première opération consiste à ajouter dans la fenêtre de conception graphique les tables qui

seront utilisées pour définir cette vue. Cliquer sur le bouton ajouter une table lorsque la fenêtre de vue est en mode création. La fenêtre suivante apparaît (Fig2.31) :


sur 132

Fig2.31 : Fenêtre Ajouter une table

Bien que le nom de cette fenêtre soit ajouter une table, elle permet également d’utiliser une vue définie au préalable pour définir une nouvelle vue. Pour pouvoir afficher les dépôts, les noms des clients et les agences, il faut donc ajouter les tables DEPOT, CLIENT et AGENCE dans la fenêtre de création. Cet ajout se fait d’après le même principe que pour une requête Access, en sélectionnant la table, et en la glissant dans la fenêtre de création graphique, tout en gardant le bouton de la souris enfoncé.


sur 132

Access va représenter automatiquement les relations entre les tables dans la fenêtre graphique (Fig2.32) d’après le schéma de la base de données.

Fig2.32: représentation graphique des tables dans le générateur de vue

Il suffit maintenant de sélectionner directement les champs qui nous intéressent, en cochant les cases en face de chaque champ (Fig2.33) :

Fig2.33 : sélection des champs dans les diverses tables

Les champs sélectionnées apparaissent dans la grille dans l’ordre où ils ont été sélectionnés dans la partie graphique. C’est également l’ordre dans lequel les colonnes seront affichées par la vue. La dernière opération consiste à fermer la fenêtre de création, et à enregistrer la vue par exemple sous le nom Dépôts avec les noms des clients et les agences.


sur 132

L’exécution de cette vue donne le résultat suivant (Fig2.34) :

Fig2.34: résultat de l’exécution de la vue

Il est également possible de définir des critères pour limiter cette vue. Comme exemple, nous allons limiter cette vue aux dépôts effectués à Lausanne. Pour cela, il est nécessaire d’ouvrir la vue en mode création. La grille comporte une colonne Critères, qui permet de saisir le critère. Saisir dans la ligne loc_ag le critère (=’Lausanne’) (Fig2.35) :

Fig2.35: Définition d'un critère

Les colonnes Ou permettent de réaliser des OU logiques entre plusieurs critères. On peut par exemple afficher les dépôts effectués à Lausanne ou à Montreux.


sur 132

Comme pour les requêtes Access, le code SQL généré lors de la création de la vue est directement modifiable depuis la fenêtre de création de vue. Pour cela, il faut passer en mode création en

cliquant sur , puis il faut cliquer sur le bouton pour afficher le code SQL de la vue (Fig2.36) :

Fig2.36 : affichage du code SQL de la vue

Une vue peut également directement être écrite en SQL. Pour cela, il suffit de saisir le code de la vue SQL depuis le générateur de vue. Il n’est pas nécessaire d’ajouter les tables concernées avant la saisie du code.(Fig2.37).

Fig2.37 : vue saisie directement en mode SQL.

Le bouton Vérifier la syntaxe SQL permet de vérifier la grammaire de la requête SQL, mais sans exécuter la requête pour créer la vue.


sur 132

2.7.2 Les procédures stockées 2.7.2.1 Introduction Petit rappel, les procédures stockées sont un moyen de créer des routines et des procédures qui sont exécutées sur le serveur. Ces procédures, qui sont des scripts Transact-SQL pré-compilés, peuvent être démarrées par une application qui les appelle, ou être appelées par des déclencheurs ou des règles de contrôle d’intégrité des données. Au niveau utilisation, les procédures stockées présentent de nombreux avantages : • Meilleures performances : les procédures stockées tournent sur le serveur, qui est en principe

plus puissant que les stations de travail, ce qui entraîne un temps d’exécution plus court. Les procédures stockées disposent également d’un accès direct à la base de données, sans avoir besoin de faire transiter les informations sur le réseau.

• Avantages au niveau du développement client-serveur : Les tâches de développement sont

bien séparées entre les logiciels client et serveur, ce qui permet une meilleure planification, et un développement complètement séparé entre les parties client et serveur de l’application.

• Sécurité accrue : L’utilisation des procédures stockées autorise une meilleure sécurité de la

base de données, en créant des procédures spécifiques pour toutes les opérations de gestion de la base de données. Les procédures permettent de définir des moyens de contrôle par code de tous les accès à la base de données.

• Application côté serveur des règles concernant les données :Les procédures stockées

permettent de mettre en place les règles et autres éléments logiques qui participent au contrôle des informations du système.

Dans le modèle Client-serveur idéal, la gestion des données incombe uniquement au serveur, et la présentation de celles-ci, ainsi que l’affichage des rapports et des résultats d’interrogation reviennent au client. Les procédures stockées permettent de placer tous les traitements des données sur le serveur. Lors de la conception du système, il faut faire particulièrement attention aux éléments qui peuvent être déplacés d’un côté ou de l’autre de la relation client-serveur, afin d’optimiser l’exploitation de l’application par l’utilisateur. Bien que le SQL Standard soit un langage non procédural, SQL Server autorise l’emploi de mots réservés pour contrôler les flux d’instruction. Par rapport aux instructions SQL dynamiques, les instructions offrent les avantages suivants : • Une procédure stockée est compilée la première fois qu’elle est utilisée, puis elle est enregistrée

dans une table système de la base de données courante. Lors de la compilation, la procédure stockée est optimisée, ce qui peut améliorer fortement les performances du système.

• Une procédure stockée peut être lancée sur un serveur local ou distant. Cela permet d’exécuter

des processus sur d’autres machines, et de dépasser le stade d’opérations sur les bases locales, en travaillant avec des informations réparties sur plusieurs serveurs.


sur 132

• Un programme d’application développé dans un langage évolué, tel que C ou Visual Basic, peut également faire appel à des procédures stockées, apportant une solution optimale pour le couple « logiciel Client/SQL Server ».

2.7.2.2 Définition d’une procédure stockée Pour créer une procédure stockée depuis la fenêtre base de données, il faut cliquer sur l’objet Procédure Stockée, puis sur le menu . Le générateur de procédure stockée apparaît (Fig2.39) :

Fig2.39: générateur de procédures stockées

Comme premier exemple, nous allons écrire une simple procédure qui affiche tous les clients. Saisir simplement les instructions suivantes dans le générateur de procédure (Fig2.40) :

Fig2.40 : procédure stockée liste des clients

Ensuite, enregistrer cette procédure sous le nom Liste_Clients. Pour l’exécuter, il suffit simplement de double-cliquer dessus dans la fenêtre de base de données, ou de lancer la commande Exécuter en cliquant sur la procédure avec le bouton droit de la souris.


sur 132

2.7.2.3 possibilités plus avancées des procédures stockées Les procédures offrent également la possibilité d’utiliser des paramètres. Il faut simplement faire précéder le nom du ou des paramètres par le symbole @, et indiquer le type de chaque paramètre à la suite de celui-ci. Dans le corps de la procédure, il faut utiliser le nom du paramètre précédé du symbole @. Comme exemple, nous allons définir une procédure pour rechercher les coordonnées d’un client. Le N° du client sera passé en paramètre de la procédure. La procédure est la suivante (Fig2.41) :

Fig2.41: utilisation des paramètres

Lors de l’exécution de cette procédure, il faut simplement lui fournir la valeur du paramètre (Fig2.42) :

Fig2.42 : valeur du paramètre

La procédure retourne comme résultat l’enregistrement suivant (Fig2.43) :

Fig2.43: résultat de la procédure stockée

Bien sûr, les procédures stockées ne se limitent pas à l’usage de l’instruction SELECT. Les instructions INSERT, DELETE et UPDATE sont également utilisables.


sur 132

Nous allons réaliser une procédure pour saisir un dépôt dont les caractéristiques sont passées en paramètres. L’opération à effectuer est la suivante : insert into DEPOT values (numero_client, numero_agence,Date_depot,Montant_depot) Point important qui mérite quelques explications supplémentaires, la table DEPOT comporte un champ num_dep, qui est un champ compteur qui permet de différencier les dépôts. Ce champ est généré automatiquement par le SGBD lors de l’insertion d’un nouvel enregistrement par exemple en mode feuille de données. Dans le cadre d’une insertion en SQL, le principe est le même ; il n’est pas nécessaire d’indiquer la présence du champ compteur lors de la définition des paramètres de la procédure, le SGBD va ajouter automatiquement le numéro num_dep, sans intervention de l’utilisateur. Les valeurs sont passées en paramètres de la procédure stockée. La procédure complète est définie par la figure suivante (2.44) :

Fig2.44: insertion d'un dépôt

Une fois cette procédure saisie, l’enregistrer sous un nom explicite, comme Saisie_Depot, puis la tester en saisissant un dépôt avec des valeurs quelconques, par exemple N° Client =6, N° Agence =5, Date dépôt = 30/11/1999, Montant dépôt =1000.-

Pour le test, cliquer sur le bouton , puis saisir les valeurs des paramètres dans les fenêtres successives. Si par exemple le N° de client n’existe pas dans la table, Le message suivant apparaît (Fig2.45b).

Fig2.45b: le N° de client n'existe pas


sur 132

Par contre, si les valeurs sont correctes, le message suivant est affiché (Fig2.46c) :

Fig2.45c: l'insertion est réussie

La procédure n’a effectivement pas retourné d’enregistrement, vu que ce n’est pas son rôle. En affichant les dépôts effectués, on constate que le dépôt a été correctement enregistré, dans ce cas avec le numéro 29 (Fig2.46) :

Fig2.46: le dépôt a été enregistré avec le N° 29

Le langage T-SQL et les procédures stockées permettent également l’emploi de structures de contrôle de flux, telles que IF…THEN, BEGIN…END, WHILE, BREAK, et CONTINUE. Ces structures permettent de définir facilement des procédures stockées plus évoluées que le SQL standard. Pour illustrer l’emploi de la structure de contrôle IF…THEN, nous allons définir une procédure stockée pour saisir les coordonnées d’un client. Cette procédure effectuera comme première opération la vérification que le client ne figure pas déjà dans la table CLIENT. Si ce n’est pas le cas, elle procédera à l’insertion des données. Pour cela, nous allons avoir besoin d’une autre fonction. Le mot-clé EXISTS permet de tester si un enregistrement existe dans une table. Le principe consiste à tester si un enregistrement avec les mêmes valeurs de champs que celles passées en paramètre de la procédure est déjà existant dans la base de données. Si l’enregistrement existe déjà, la procédure ne fait aucune opération. Dans le cas contraire, les coordonnées du nouveau client sont insérées dans la table. En pseudo-code, la procédure est la suivante. Procédure Insertion avec contrôle (Coordonnées) : Si CLIENT (Coordonnées) n’existe pas ALORS INSERER(coordonnées)


sur 132

Le code de la procédure stockée à saisir est le suivant(Fig2.47) :

Fig2.47: Saisie Client avec Contrôle

Point intéressant, la fonction exists nécessite le passage en paramètre d’une requête SELECT sur la table concernée. Il suffit ensuite de tester cette procédure stockée, d’abord en passant en paramètre les coordonnées d’un client qui figure déjà dans la base de données, et en vérifiant ensuite dans la table CLIENT si les coordonnées ont été enregistrées, puis en saisissant de nouvelles coordonnées. Bien sûr, l’étape suivante consiste à afficher des messages de contrôle, mais ce point est encore à traiter, par exemple avec un peu de programmation en visual Basic. Les procédures stockées permettent également de définir des variables locales ou globales. La définition d’une variable locale se fait de la manière suivante : DECLARE @nom_variable type de données [,@nom_variable type de données ] Une variable locale doit être déclarée dans le même lot ou dans la même procédure où elle est utilisée. Elle peut être utilisée comme compteur, ou comme espace temporaire de stockage pour d’autres variables. Pour affecter une valeur à une variable, il faut utiliser une instruction SELECT habituelle. Par exemple, on peut déclarer un compteur de la façon suivante : Declare @nombre int SELECT @nombre = count (*) from CLIENT si le SELECT retourne plus d’une valeur, la variable reçoit la dernière valeur retournée. SQL Server 7 ou MSDE disposent de nombreuses variables globales prédéfinies, dont la description détaillée sort du cadre de cette notice. En cas de nécessité, le plus simple est de se référer à l’aide pour obtenir la liste et le rôle de ces variables globales.


sur 132

2.8 Etats, Pages d’accès aux données, Création d’une petite application La définition d’un état , d’une page d’accès aux données ou d’une petite application dans un projet de données ne diffère pas de sa définition dans une base de données utilisant JET. Ces points ont déjà été expliqués dans le chapitre 1, et ne seront pas repris dans ce chapitre. 2.9 Migration d’une base de données JET vers MSDE/SQL Server La migration d’une base de données JET vers SQL Server peut être effectuée à l’aide de l’assistant Migration SQL Server. Celui-ci se trouve dans le menu Outils => utilitaires de base de données =>Assistant de migration SQL Server (Fig2.48) :

Fig2.48: assistant de migration SQL Server


sur 132

La première étape consiste à déterminer si la migration doit être effectuée en utilisant une base de données existante ou en créant une nouvelle base de données (Fig2.49)

Fig2.49: utilisation d'une base de données existante ou création d'une nouvelle base de données

Dans le cas de cette migration, nous allons créer une nouvelle base de données. L’étape suivante permet de définir le serveur sur lequel la base de données sera placée, ainsi que le nom de cette base et les informations de connexion. Cette fenêtre est la même que lors de la création d’un projet Access (Fig2.50) :

Fig2.50: choix du serveur et définition de l'utilisateur et du nom de la base de données qui est créée


sur 132

Il faut ensuite sélectionner les tables qui seront migrées vers SQL Server 7 (Fig2.51) :

Fig2.51: sélection des tables qui seront migrées vers SQL Server

L’assistant permet ensuite de préciser les attributs de la base de données qui seront également exportés (Fig2.52). En principe, les utilisateurs devront garder les valeurs par défaut.

Fig2.52: définition des attributs de la base de données JET à exporter


sur 132

La dernière étape consiste à définir si l’application doit être modifiée (Fig2.53a). Dans notre cas, choisir l’option Pas de modification pour l’application.

Fig2.53a: ne pas modifier l'application existante

Maintenant, cliquer sur le bouton Terminer. L’assistant effectue la conversion, puis édite un rapport, qui détaille la migration effectuée. En ouvrant Entreprise Manager de SQL Server sur le serveur EINEV_NT11, on constate que la base de données migration de banque_jet a effectivement été créée (Fig2.54) :

Fig2.54 : La base de données a été crée dans SQL Server 7


sur 132

L’option Créer une nouvelle application client-serveur Access de la figure 2.53 permet de créer un projet de données Access en liaison avec la base de données SQL Server. Le serveur SQL Server 7 peut sans difficulté être remplacé par un serveur MSDE pour héberger la base de données. 2.10 Migration d’une base de données MSDE/SQL Server vers JET Pour faire migrer un projet Access vers une base de données JET, la première opération est de créer la base de données JET dans Access2000 (Fichier .mdb). Par exemple, définir une base de données Migration depuis projet_banque_utilisation. Ensuite, il faut utiliser l’assistant Import and Export Data de SQL Server 7 (Fig2.55a) ou de MSDE (Fig2.55b).

Fig2.55a : assistant d’exportation des données de SQL Server 7

Fig2.55b : assistant d’exportation des données de MSDE


sur 132

La première étape consiste à préciser quelle est la source de données à exporter. Il faut définir le format de la source, le serveur, l’authentification et le nom de la base de données à exporter (Fig2.56) :

Fig2.56: définition de la source des données à exporter

Il faut ensuite sélectionner la destination des données(Fig2.57).

Fig2.57: destination des données

Comme déjà précisé, la base de données de destination doit déjà être créée avant l’exportation des données, et ne doit aussi ne pas être utilisée au moment de l’exportation des données. Dans le cas contraire, l’assistant refuse de sélectionner cette base de données.


sur 132

L’étape suivante permet de choisir si l’exportation doit être une copie complète des tables, ou si l’assistant doit utiliser une requête pour limiter les informations qu’il va exporter (Fig2.58)

Fig2.58: exportation complète des tables ou d'après une requête

Dans notre cas, nous allons exporter la totalité des tables. Si l’utilisateur veut définir une requête, il va simplement l’éditer lors d’une étape intermédiaire (sans illustration). Ensuite, il faut sélectionner les tables à exporter, puis indiquer quand l’exportation sera effectuée lors de l’étape suivante (sans illustrations, l’assistant est le même que pour l’importation des données). L’exportation vers Access est ensuite effectuée. Un message de confirmation est affiché si l’exportation n’a pas rencontré de problème (Fig2.59).

Fig2.59 : confirmation de l’exportation des données vers Access

Limitation importante de la migration, seules les tables de la base de données ont été converties. Les autres objets de la base de données MSDE (procédures stockées, schéma de base de données) sont perdus lors de la migration.


sur 132

2.11 Conclusion sur MSDE MSDE est sans aucun doute la nouveauté la plus importante de Access2000. Bien que plus complexe que celle de JET, son utilisation en liaison avec l’interface d’Access2000 permet de se familiariser à peu de frais avec la puissance et la philosophie d’utilisation de SQL Server 7 ce qui présente un grand avantage dans le cadre de l’utilisation à l’eivd. La plupart des notions étudiées dans ce chapitre peuvent être utilisées indifféremment sur un serveur SQL Server 7 ou MSDE. MSDE peut également être entièrement administré depuis Entreprise Manager de SQL Server 7. Cela présente l’avantage d’une administration centralisée dans le cas d’un labo de base de données sur MSDE. Un seul serveur SQL Server 7 aurait la possibilité d’administrer par exemple une salle de 25 machines avec Access2000 et MSDE installés. D’un point de vue didactique, je ne peux que recommander le passage à la version Access2000 de Access. La possibilité d’utiliser MSDE permet de se familiariser avec l’utilisation de SQL Server 7, avec des coûts beaucoup plus faibles, tant au niveau de la configuration hardware que des licences. Cela peut permettre à une classe complète de se familiariser avec SQL Server 7, au lieu de seulement quelques étudiants pendant les travaux de semestres ou de diplôme. Pour les développeurs, MSDE présente une possibilité intermédiaire entre JET et SQL Server 7. Grâce à sa compatibilité totale avec SQL Server 7, Il offre une meilleure évolutivité des applications développées, surtout si leurs besoins risque d’augmenter fortement. Il offre également quelques possibilités intéressantes, comme l’utilisation de la sécurité intégrée de Windows NT/2000, et tout cela pour des coûts de licences inférieurs à une solution basée sur SQL Server 7.


sur 132

Chapitre 3. LANGAGE SQL Le langage SQL tend aujourd’hui à s’imposer dans la majorité des systèmes de gestion de bases de données et Access ne manque pas à l’appel puisqu’il implémente une version du langage : Access SQL. Ce chapitre a pour but de présenter les fonctions de base du langage SQL. Egalement, ce chapitre va proposer une petite présentation du langage Transact-SQL (T-SQL), autre « dialecte » SQL utilisé par Microsoft pour SQL Server 7 et MSDE. Par contre, ce chapitre n’a pas pour ambition de présenter toutes les fonctions offertes par JET SQL. Pour cela, le plus simple est de recourir à l’aide de Access2000, qui fournit les explications pour l’utilisation des instructions SQL. 3.1. Introduction Le moteur de base de données Microsoft JET 4.x est généralement conforme à la norme ANSI-SQL89 niveau 1, qui est un complément de la norme ANSI SQL-86. Toutefois, certaines fonc tions ANSI SQL ne sont pas mises en oeuvre dans Jet SQL. Avec JET 4.X, le fournisseur Microsoft OLE DB pour Jet met à disposition davantage de syntaxe ANSI SQL-92. Inversement, le moteur Microsoft Jet SQL possède des mots réservés et des caractéristiques non gérés dans le SQL ANSI. 3.2. Les nouveautés de SQL JET4.0 L’objectif principal des nouvelles extensions SQL du moteur de base de données JET 4.0 d’Access2000 est de réduire le nombre de modifications nécessaires des instructions SQL pour adapter les applications traditionnelles Access2000 JET aux projets de données Access, qui permettent la connexion au moteur MSDE ou SQL Server 7 (Cf. chapitre 2). Toutes les versions de SQL Server utilisent le langage T-SQL, l’autre dialecte SQL de Microsoft. Le langage SQL JET 4.0 se rapproche de plus en plus de SQL ANSI-92. SQL JET 4.0 offre de nombreuses nouvelles instructions, ainsi que des instructions améliorées pour la définition des données. Les plus intéressantes sont les suivantes : • CREATE USER, ALTER USER, DROP USER, CREATE GROUP, ALTER GROUP,

DROP GROUP pour la gestion des utilisateurs et des groupes. • GRANT et REVOKE pour ajouter ou supprimer des autorisations utilisateurs sur des

objets de la base de données. • CREATE et DROP VIEW pour ajouter ou supprimer des objets SELECT QueryDef. • CREATE et DROP PROCEDURE pour ajouter ou supprimer des objets SELECT

QueryDef, y compris des requêtes Action. • BEGIN et COMMIT TRANSACTIONS pour l’utilisation des transactions. Dans les nouveautés qui intéressent plus les développeurs d’applications, JET SQL 4.0 met maintenant à disposition quatre méthodes qui permettent de modifier la base de registre Windows. L’emploi de ces méthodes sort du cadre de cette notice, et n’y sera pas traité. L’aide fournit toutes les informations nécessaires quant à l’usage de ces méthodes en cas de besoin.


sur 132

3.3 Comparaison entre SQL JET 4.0 et ANSI-SQL 3.3.1 Différences principales • Le moteur JET SQL et SQL ANSI possèdent chacun des mots réservés et des types de données

qui leur sont propres. Le tableau suivant, repris de l’aide de Access2000, répertorie les types de données SQL ANSI et leurs équivalents pour le langage SQL du moteur de base de données Microsoft Jet ainsi que leurs synonymes autorisés. Il dresse également la liste des types de données Microsoft® SQL Server équivalents.

Type de données SQL ANSI

Type de données SQL du moteur Jet

Synonyme

Type de données SQL du moteur Jet

BIT, BIT VARYING BINARY (voir remarques) VARBINARY, BINARY VARYING BIT VARYING

BINARY, VARBINARY

Non gérés BIT (voir remarques) BOOLEAN, LOGICAL, LOGICAL1, YESNO

BIT

Non gérés TINYINT INTEGER1, BYTE TINYINT Non gérés BINARY (voir remarques) AUTOINCREMENT BINARY (voir remarques) Non gérés MONEY CURRENCY MONEY DATE, TIME, TIMESTAMP DATETIME DATE, TIME (voir remarques) DATETIME Non gérés UNIQUEIDENTIFIER GUID UNIQUEIDENTIFIER DECIMAL DECIMAL NUMERIC, DEC DECIMAL REAL REAL SINGLE, FLOAT4, IEEESINGLE REAL DOUBLE PRECISION, FLOAT Float DOUBLE, FLOAT8,

IEEEDOUBLE, NUMBER (voir remarques)

Float

SMALLINT SMALLINT SHORT, INTEGER2 SMALLINT INTEGER INTEGER LONG, INT, INTEGER4 INTEGER INTERVAL Non gérés Non gérés Non gérés IMAGE GENERAL, OLEOBJECT IMAGE Non gérés BIT (voir remarques) LONGTEXT, LONGCHAR,

MEMO, NOTE, NTEXT (voir remarques)

TEXT

CHARACTER, CHARACTER VARYING, NATIONAL CHARACTER, NATIONAL CHARACTER VARYING

BINARY (voir remarques) TEXT(n), ALPHANUMERIC, CHARACTER, STRING, VARCHAR, CHARACTER VARYING, NCHAR, NATIONAL CHARACTER, NATIONAL CHAR, NATIONAL CHARACTER VARYING, NATIONAL CHAR VARYING (voir remarques)

CHAR, VARCHAR, NCHAR, NVARCHAR

Remarques

• Le type de données BIT SQL ANSI n'est pas l'équivalent du type de données BIT SQL Microsoft Jet. Il corresp ond plutôt au type de données BINARY. SQL ANSI n'a pas d'équivalent pour le type de données BIT du langage SQL du moteur Jet.

• TIMESTAMP n'est plus pris en charge comme synonyme de DATETIME. • NUMERIC n'est plus pris en charge comme synonyme de FLOAT ou DOUBLE. NUMERIC est maintenant utilisé comme synonyme de

DECIMAL. • Un champ LONGTEXT est toujours stocké dans le format de représentation Unicode. • Si le nom de type de données TEXT est utilisé sans spécification de la longueur facultative, TEXT(25) par exemple, un champ

LONGTEXT est créé. Cela permet d'écrire des instructions CREATE TABLE fournissant des types de données cohérents avec Microsoft SQL Server.

• Un champ CHAR est toujours enregistré dans le format de représentation Unicode, qui équivaut au type de données ANSI SQL NATIONAL CHAR.

• Si le nom de type de données TEXT est utilisé et si la longueur facultative est spécifiée, TEXT(25) par exemple, le type de données du champ équivaut au type de données CHAR. Cela préserve la compatibilité ascendante pour la plupart des applications Microsoft Jet, tout en permettant au type de données TEXT (sans spécification de longueur) d'être aligné avec Microsoft SQL Server.


sur 132

• JET accepte à la fois les caractères génériques ANSI SQL et spécifiques JET à utiliser avec

l’opérateur Like.

Caractère équivalent SQL JET SQL ANSI Tout caractère isolé ? _(souligné) 0, 1 ou plusieurs caractères * %

L’utilisation des caractères génériques ANSI exclut celle des caractères génériques JET, et inversement. Vous pouvez donc utiliser soient les caractères de remplacement ANSI SQL, soient les caractères de remplacement de SQL JET, mais vous ne pouvez pas utiliser les deux jeux de caractères en même temps

• SQL JET est généralement moins restrictif que ANSI SQL. Par exemple, il permet de regrouper et d’ordonner des expressions.

• Le Langage SQL JET permet d’employer des expressions plus puissantes. 3.3.2. Fonctions avancées du langage SQL du moteur Jet Le langage SQL du moteur Jet possède les fonctions avancées suivantes : • L'instruction TRANSFORM qui permet de réaliser des requêtes croisées. Une requête croisée

est une requête qui effectue une somme, une moyenne, un décompte ou tout autre type d'opération sur des enregistrements, puis regroupe le résultat en deux types d'informations — l'un sur le côté gauche d'une grille (titres de ligne) et l'autre sur la partie supérieure (titres de colonne).

• Des fonctions d'agrégation supplémentaires, notamment StDev et VarP. Les fonctions

d'agrégation SQL permettent d'obtenir des données statistiques sur des ensembles de valeurs. Les fonctions avg ou count sont des fonctions d’agrégations.

• La déclaration PARAMETERS qui permet de définir des requêtes Paramètre, Une requête

paramétrée est une requête qui, lors de son exécution, affiche une boîte de dialogue qui vous invite à lui transmettre des informations, telles que des critères pour extraire des enregistrements ou une valeur à insérer dans un champ.


sur 132

3.3.3 Fonctions SQL ANSI non gérées par SQL JET Le langage SQL du moteur Jet ne possède pas les fonctions SQL ANSI suivantes : • Les références de fonction d'agrégation DISTINCT. Par exemple, le langage SQL du moteur Jet

n'autorise pas l'expression SUM(DISTINCT nom_de_colonne). • La clause LIMIT TO nn ROWS qui sert à limiter le nombre des lignes renvoyées par une

requête. Vous ne pouvez utiliser que la clause WHERE pour limiter l'étendue d'une requête.


sur 132

3.4. Les instructions de base 3.4.1. Instruction SELECT La syntaxe simplifiée est la suivante :

SELECT [attribut] { * | table.* | [table.]champ1 [, [table.]champ2.[, ...]]} [AS pseudonyme1 [, pseudonyme2 [, ...]]] FROM expression_de_table [, ...] [IN base_de_données_externe] [WHERE... ] [GROUP BY... ] [HAVING... ] [ORDER BY... ] [WITH OWNERACCESS OPTION]

• Access autorise les noms d’objets formés de chaîne jusqu’à 64 caractères contenant

des caractères spéciaux, accentués et des espaces. Pour faire référence à ces noms dans une requête SQL, ils doivent être placés entre crochets. Par exemple :

SELECT [Numéro Client], [Nom du client], FROM [Table des clients];

Les noms qui respectent le standard SQL n’ont pas besoin d’être mis entre crochets. • Si Access ne peut pas déterminer un élément de la requête, il ne provoque pas

vraiment d’erreur, mais affiche une boîte de dialogue pour en demander la valeur. Cette caractéristique est très utile pour écrire des requête paramétrées. On peut par exemple écrire :

SELECT * FROM DEPOT WHERE mont_dep < [Montant maximum];

où [Montant Maximum] n’est pas défini dans le système. Access affiche alors la boîte

de dialogue suivante :

Fig3.1 : Saisie de la valeur du paramètre

Access utilise alors cette valeur pour effectuer la requête.


sur 132

• En plus des attributs standards ALL et DISTINCT, Access en supporte deux autres : DISTINCTROW : élimine les lignes entièrement dupliquées, pas seulement sur un

champ comme avec l’attribut DISTINCT.

TOP n : renvoie les n premiers enregistrements qui résultent d’une requête triée avec la clause ORDER BY. Par exemple, on désire les 3 dépôts avec les montants les plus élevés :

SELECT TOP 3 num_dep,mont_dep FROM DEPOT ORDER BY mont_dep DESC;

• La clause IN (pas dans la norme) permet de spécifier le chemin d’une base externe.

Une instruction SELECT est donc capable d’extraire des enregistrements d’une table appartenant à n'importe quelle base de données à laquelle Access peut se connecter, qu'il s'agisse d'une base de données dBASE ou Paradox, ou encore d'une base de données Microsoft Access qui n'est pas la base de données active.

La syntaxe à utiliser pour extraire des enregistrements d’une table dBASE IV est la

suivante (si cette dernière n’est pas attachée) :

SELECT * FROM employes IN 'c:\temp\test.dbf' "dBASE IV;" WHERE nom = "Bartoli";

dBASE IV est ici un identificateur qui indique à Access d’effectuer la requête dans le

fichier c:\temp\test.dbf. Les jointures • La clause FROM accepte un (ou des) nom(s) de table(s), conformément à la norme,

mais elle permet également de spécifier une jointure entre plusieurs table. Access permet d’effectuer 3 types de jointures illustrées ci-dessous avec les tables simplifiées CLIENT et DEPOT suivantes :

No Client Nom Localité

1 ACHILLE MORGES

2 ROBERTO LAUSANNE

3 MORGAN SERVION

4 TCHUDI NYON

5 DUPOND CHAVANNES

6 BARTOLI CRISSIER

7 DUDRAGNE VEVEY

11 VUADENS LAUSANNE

No de dépôt No Client Montant

1 5 SFr. 500.00

2 2 SFr. 700.00

3 6 SFr. 350.00

4 7 SFr. 900.00

5 5 SFr. 700.00

6 11 SFr. 750.00

7 7 SFr. 300.00


sur 132

L’équijointure La plus courante, cette jointure sélectionne tous les clients qui ont un dépôt :

SELECT distinct nom_cli, num_dep FROM CLIENT INNER JOIN DEPOT ON CLIENT.num_cli= DEPOT.num_cli;

Nom No de dépôt

ROBERTO 2

DUPOND 1

DUPOND 5

BARTOLI 3

DUDRAGNE 4

DUDRAGNE 7

VUADENS 6

La jointure gauche Cette jointure sélectionne tous les clients, y compris ceux qui n'ont pas de dépôts.

SELECT distinct nom_cli, num_dep FROM CLIENT LEFT JOIN DEPOT ON CLIENT.num_cli= DEPOT.num_cli;

Nom No de dépôt

ACHILLE

ROBERTO 2

MORGAN

TCHUDI

DUPOND 1

DUPOND 5

BARTOLI 3

DUDRAGNE 4

DUDRAGNE 7

VUADENS 6

La jointure droite Cette jointure affiche tous les dépôts et leur propriétaire, même les dépôts qui

n'appartiennent à personne (dans notre cas tous les dépôts ont un propriétaire).

SELECT distinct nom_cli, num_dep FROM CLIENT RIGHT JOIN DEPOT ON CLIENT.num_cli= DEPOT.num_cli;

Nom No de dépôt

BARTOLI 3

DUDRAGNE 4

DUDRAGNE 7

DUPOND 1

DUPOND 5

ROBERTO 2

VUADENS 6

Ces spécifications de jointures, qui ne font pas partie de la norme 86, sont des

éléments repris dans la nouvelle norme SQL.


sur 132

• Le renommage des champs ou des expressions sur les champs n’est pas conforme à la norme. La requête suivantes N’EST PAS acceptée :

SELECT moyenne=avg(mont_dep) FROM DEPOT;

Dans Access, le renommage des colonnes doit se faire avec le mot réservé AS. Mais

cette opération ne sert qu’à modifier l’affichage dans la feuille de réponse. On ne peut pas faire référence à "moyenne" dans une clause WHERE, par exemple. On sera donc obligé de répéter "avg(mont_dep)".

SELECT avg(mont_dep) AS moyenne FROM DEPOT;

Le renommage des tables, par contre, est standard. La requête suivante est acceptée.

Mais il est également possible d’utiliser le mot réservé AS (client AS c) :

SELECT c.num_cli, nom_cli, date_dep, mont_dep*2 AS DoubleMontant FROM CLIENT c, DEPOT d WHERE c.num_cli=d.num_cli;

• Access permet d’effectuer des opérations de regroupement et de tri sur des

expressions, même si ces dernières ne font pas partie de la sélection.

SELECT num_ag, max(mont_dep) AS maximum, min(mont_dep) AS minimum FROM DEPOT GROUP BY num_ag ORDER BY avg(mont_dep);

• L’attribut DISTINCT n’est pas supporté dans une fonction de regroupement. Par

exemple, il est impossible d’écrire :

SELECT count(DISTINCT num_ag) FROM DEPOT;

Mais l’attribut DISTINCT est tout de même supporté dans les autres cas. On peut donc

écrire une requête nommée "DistDep" de la manière suivante :

SELECT DISTINCT num_ag FROM DEPOT;

Et utiliser cette dernière pour compter les départements :

SELECT count(num_ag) FROM DistDep;


sur 132

Conditions de recherches • Access supporte les opérateurs de comparaisons standards : =, <>, >, >=, <, <= • Comme dans la norme, une requête utilisée dans une comparaison doit renvoyer une

valeur unique. Mais la requête peut être placée à gauche de l’opérateur et il est possible de comparer deux sous requêtes.

• Avec le prédicat "Between expr1 And expr2", la norme indique que expr1 doit être

inférieur à expr2. Ce n’est pas le cas dans Access qui permet d’inverser les deux valeurs SANS QUE le résultat de la requête ne soit changé.

• Le prédicat "Like expression" est supporté, mais comme dans la plupart des SGBD

commerciaux, les caractères jokers "%" et "_" sont remplacés par "*" et "?". Le tableau suivant donne quelques exemples de comparaisons :

Type de correspondance Modèle Correspondance

(l'expression retourne True) Pas de correspondance (l'expression retourne False)

Plusieurs caractères "a*a" "aa", "aBa", "aBBBa" "aBC" Caractère spécial "a[*]a" "a*a" "aaa" Plusieurs caractères "ab*" "abcdefg", "abc" "cab", "aab" Un seul caractère "a?a" "aaa", "a3a", "aBa" "aBBBa" Un seul chiffre "a#a" "a0a", "a1a", "a2a" "aaa", "a10a" Plage de caractères "[a-z]" "f", "p", "j" "2", "&" Hors plage "[!a-z]" "9", "&", "%" "b", "a" Valeur autre qu'un chiffre "[!0-9]" "A", "a", "&", "~" "0", "1", "9" Combinaison "a[!b-m]#" "An9", "az0", "a99" "abc", "aj0"

• Les prédicats IN, ALL-or-ANY, EXISTS et IS NULL sont supportés conformément à la

norme. Le prédicat ANY n’exige pas que la condition soit vraie pour au moins une des valeurs.

Fonctions de regroupement • Access supporte les fonctions de regroupement standard : COUNT, MIN, MAX, AVG,

SUM et en propose 4 autres :

• StDevP / StDev : écart type d’une population / échantillon de population. • VarP / Var : variance d’une population / échantillon de population.


sur 132

3.4.2. Instruction INSERT Requête Ajout pour plusieurs enregistrements :

INSERT INTO cible [IN base_de_données_externe] SELECT [source.]champ1[, champ2[, ...] FROM expression_de_table

Requête Ajout pour un seul enregistrement :

INSERT INTO cible [(champ1[, champ2[, ...]])] VALUES (valeur1[, valeur2[, ...])

• La clause IN (pas dans la norme) permet de spécifier le chemin d’une base externe.

Une instruction INSERT est donc capable d’insérer des enregistrements dans une table appartenant à n'importe quelle base de données à laquelle Access peut se connecter, qu'il s'agisse d'une base de données dBASE ou Paradox, ou encore d'une base de données Microsoft Access qui n'est pas la base de données active.

• Dans une instruction INSERT suivie d’un SELECT, Access permet que les tables

source et cible soient les mêmes, pour autant que la table cible ne possède pas de clé primaire (puisque l’insertion provoquerait des doublons qui seraient refusés). C’est assez déconcertant car on voit mal l’utilité d’une telle requête qui ne servirait qu’a engendrer des doublons dans une table.

• La cible peut être un requête qui fonctionne alors comme une vue. Mais lors de

l’insertion, Access ne vérifie pas que les lignes insérées respectent la définition de la requête.

Soit une requête "ClientLausanne" définie de la manière suivante :

SELECT * FROM CLIENT2 (même structure que la table CLIENT) WHERE CLIENT2.loc_cli='LAUSANNE';

Access permet l’exécution de l’instruction suivante et insère les tuples concernés dans

la requête, donc dans la table CLIENT2 :

INSERT INTO ClientLausanne SELECT * FROM CLIENT WHERE loc_cli='NYON';

Il faut donc être très prudent lorsque l’on associe une requête à la notion de vue ! • Access fait une erreur en sauvegardant une requête ajout qui comporte la clause

VALUES (insertion d’un seul enregistrement). En effet, considérons la requête suivante :

INSERT INTO CLIENT VALUES (12, 'Jacquier', 'sss',12, 'NW', 1212);

On peut sans problème taper, exécuter et sauvegarder cette requête depuis la fenêtre

SQL. Elle sera alors ajoutées à la liste des requêtes dans la fenêtre "Base de données".


sur 132

Mais si l’on recharge cette requête (pour la modifier par exemple), elle apparaît sous la forme suivante :

INSERT INTO CLIENT SELECT 12, 'Jacquier', 'sss', 12, 'NW', 1212;

Il s’agit réellement d’une erreur car la requête sous cette forme n’est pas exécutable.

Access signale une erreur de syntaxe. Cette erreur n’est toutefois pas trop pénalisante car on voit mal l’utilité de sauvegarder une telle requête dans le but de la réexécuter plus tard.

• Les valeurs insérées peuvent être des expressions. Par exemple une fonction Access

Basic sur une chaîne de caractère ou un expression mathématique :

INSERT INTO CLIENT VALUES (12, UCase('Jacquier'), 'sss',12, 'NW', 1212);

La ligne insérée est la suivante :

No Client Nom Rue Numéro Localité NPA

12 JACQUIER sss 12 NW 1212

• La table cible doit être un table existante, mais il est possible de créer un requête

"création de table" qui insèrera les tuples dans une nouvelle table. Il s’agit de l’équivalent de l’instruction "create table ... as select ..." de Ingres. La syntaxe à utiliser dans Access est la suivante :

SELECT * INTO ClientsLausannois FROM CLIENT WHERE loc_cli = 'LAUSANNE';

Le nom, le type de données et la taille des champs sont recopiés dans la nouvelle table,

mais celle-ci n’hérite ni de la clé primaire ni de ses autres propriétés de table et de champs.


sur 132

3.4.3. Instruction DELETE La syntaxe est la suivante :

DELETE [table.*] FROM expression_de_table WHERE critère

L’instruction DELETE supporte les requêtes conformes à la norme comme :

DELETE FROM CLIENT;

DELETE FROM CLIENT WHERE nom_cli=‘TCHUDI’;

• Access permet que la clause WHERE contienne une sous-requête qui fasse référence

à la table cible :

DELETE FROM DEPOT WHERE mont_dep > (SELECT 1.3*avg(mont_dep) FROM DEPOT);

• Il est également possible de spécifier un nom de requête à la place d’un nom de table.

Pour supprimer tous les clients de Lausanne, on pourra utiliser la requête "ClientLausanne" définie plus haut et écrire :

DELETE FROM ClientLausanne;

• La clause FROM doit être suivie d’une expression_de_table et non d’un nom de table

unique, ce qui signifie qu’il est possible de spécifier une jointure à la place du nom de table. Par exemple, si l’on désire effacer tous les dépôts d’un client donné, on peut spécifier une jointure entre la table DEPOT et la table CLIENT. Dans ce cas, on doit spécifier dans quelle table les enregistrement devront être supprimés :

DELETE DEPOT.* FROM CLIENT INNER JOIN DEPOT ON CLIENT.num_cli = DEPOT.num_cli WHERE nom_cli='Bartoli';

• Le même résultat pourrait être obtenu en exécutant la requête suivante :

DELETE FROM DEPOT WHERE num_dep IN (SELECT num_dep FROM DEPOT,client WHERE CLIENT.num_cli = DEPOT.num_cli AND nom_cli = 'Bartoli');


sur 132

3.4.4. Instruction UPDATE La syntaxe est la suivante :

UPDATE table SET (liste d’affectations) WHERE critère;

L’instruction UPDATE supporte les requêtes conformes à la norme comme :

UPDATE DEPOT SET mont_dep = mont_dep *1.05;

UPDATE DEPOT SET mont_dep = mont_dep *1.05, date_dep = #1/1/95# WHERE date_dep > #01/08/94#;;

• Comme pour les instruction INSERT et DELETE, la clause WHERE peut contenir une

référence à la table cible. Par exemple :

UPDATE DEPOT SET mont_dep = mont_dep *1.2 WHERE mont_dep < (SELECT avg(mont_dep) FROM DEPOT);

• La table cible peut également être le résultat d’une jointure. On peut par exemple

augmenter les montants de tous les dépôts de Bartoli :

UPDATE CLIENT INNER JOIN DEPOT ON CLIENT.num_cli = DEPOT.num_cli SET mont_dep = mont_dep*1.1 WHERE CLIENT.nom_cli = 'Bartoli';

• L’expression d’affectation peut prendre une des formes suivantes :

Expression Commentaire ‘Bartoli’ Remplace les valeurs par ‘Bartoli’ #4/3/94# Remplace les valeurs par 4 mars 1994 Oui Remplace les valeurs Non par Oui dans un

champ Booléen "Loc :"&Loc_cli Ajoute (par concaténation) Loc : au début de

chaque nom de localité spécifié Prix unitaire *Quantité Calcule le produit de Prix unitaire et de

Quantité pour chaque ligne. Mont_dep*1.5 Augmente de 50 pour cent les dépôts


sur 132

3.5. Quelques instructions particulières de SQL JET La plupart de ces instructions existent à la fois dans SQL JET et dans ANSI-SQL, mais leurs utilisations présentent quelques différences. Les instructions de SQL JET ne fonctionnent le plus souvent qu’avec des bases de données JET. 3.5.1. Instruction CREATE TABLE La syntaxe de l’instruction CREATE TABLE est la suivante :

CREATE [TEMPORARY] TABLE table (champ1 type [(taille)] [NOT NULL] [WITH COMPRESSION | WITH COMP] [index1] [, champ2 type [(taille)] [NOT NULL] [index2] [, ...]] [, CONSTRAINT indexmultichamp [, ...]])

Les clauses d’index sont bien sûr optionnelles et Access accepte les requêtes de définition des données vues au cours telle que :

CREATE TABLE CLIENT2 ( num_cli integer , nom_cli char(30), rue_cli char(30), num_rue char(6), loc_cli char(30), npa_cli char(6) );

Access reconnaît les types de données standard : CHARACTER, NUMERIC, INTEGER, SMALLINT, FLOAT, REAL et DOUBLE PRECISION. Mais tout comme Ingres, il ne reconnaît pas le type DECIMAL. Par contre, il fournit tous les types présentés dans le guide d’introduction, dont MONEY et DATE. Paradoxalement, Access ne permet pas de spécifier une contrainte d’intégrité NOT NULL ou UNIQUE lors de la création en mode SQL, bien qu’il soit possible de la spécifier dans les propriétés de la table en "Mode création" (voir "Définition des données" dans le guide d’introduction). Les clauses UNIQUE et DISALLOW NULL peuvent toutefois être utilisées lors de la création d’un index. La commande CREATE TABLE offre une extension importante par rapport à la norme 86, à savoir la création d’index et de contraintes d’intégrité référentielle sur des clés externes. Ces notions font partie d’une extension de la norme paru en 89, mais la syntaxe n’est pas exactement la même. Notamment, la définition d’un index à la création s’effectue à l’aide du mot réservé CONSTRAINT, qui ne fait pas partie de la norme 89. La fonction CREATE TABLE de JET 4.0 ne gère pas les bases de données non créées avec JET. Index monochamp :

CONSTRAINT nom_index {PRIMARY KEY | UNIQUE | REFERENCES table_externe [(champ_externe)]}

Index multichamp : CONSTRAINT nom_index {PRIMARY KEY (primaire1[, primaire2 [, ...]]) | UNIQUE (unique1[, unique2 [, ...]]) | FOREIGN KEY (réf1[, réf2 [, ...]]) REFERENCES table_externe [(champ_externe1 [, champ_externe2 [, ...]])]}


sur 132

Argument Description Nom Le nom de l'index à créer. primaire1, primaire2 Le nom du champ ou des champs à désigner comme clé

primaire. unique1, unique2 Le nom du champ ou des champs à désigner comme clé

unique. réf1, réf2 Le nom d'un champ ou de champs clé externe qui se réfèrent

à une autre table. table_externe Le nom de la table externe qui contient le champ ou les

champs spécifiés par champ_externe. champ_externe1, champ_externe2 Le nom du champ ou des champs de table_externe

spécifié(s) par réf1, réf2. On peut omettre cette clause si le champ référencé est la clé primaire de table_externe.

L’exemple suivant illustre la création d’index et de contraintes d’intégrités référentielles sur le schéma Clients - Dépôt. Dans cet exemple, le champ "num_cli" de la table DEPOT est une clé externe de la table CLIENT qui a été importée lors du passage entre le modèle entités-association et le modèle relationnel des données.

Fig. 66 : Relations entre les tables CLIENT et DEPOT

Imaginons que la table CLIENT existe déjà dans la base de données et que l’on désire créer la table DEPOT. On désire spécifier les contraintes suivantes :

• Le champ num_dep doit être la clé primaire. • La table doit être indexée sans doublons sur les champs "num_cli", et "num_ag". • Le champ "num_cli" doit être défini comme clé externe, de manière à applique

l’intégrité référentielle sur la table DEPOT. Cette contrainte signifie que pour tout clients insérés dans la table, Access vérifiera que la valeur de "num_cli" dans DEPOT corresponde à un "num_cli" existant dans la table CLIENT. De la même manière, Access ne permettra pas la suppression d’un enregistrement de la table DEPOT si un ou plusieurs clients y font référence.

L’instruction SQL de création de la table DEPOT est alors la suivante :

CREATE TABLE DEPOT ( num_dep integer CONSTRAINT dep_num PRIMARY KEY, num_cli integer CONSTRAINT cli_num UNIQUE, num_ag integer CONSTRAINT ag_num UNIQUE, date_dep date, mont_dep Money, CONSTRAINT cli_dep FOREIGN KEY (num_cli) REFERENCES CLIENT (num_cli) );


sur 132

L'attribut WITH COMPRESSION a été ajouté pour les colonnes CHARACTER en raison de la modification apportée au format de représentation des caractères Unicode. Les caractères Unicode nécessitent deux octets pour chaque caractère. Pour les bases de données Microsoft Jet existantes contenant des données à prédominance caractères, la conversion d'un fichier de base de données au format Microsoft Jet 4.0 peut presque doubler la taille du fichier. Toutefois, la représentation Unicode de plusieurs jeux de caractères, ceux jusque ic i désignés comme des jeux de caractères mono-octet (SBCS), peut être facilement compressée en un octet unique. Si vous définissez une colonne CHARACTER avec cet attribut, les données seront automatiquement compressées lors de leur stockage et décompressées lors de leur extraction de la colonne.


sur 132

3.5.2. Instruction CREATE INDEX L’instruction CREATE INDEX permet de créer un nouvel index sur une table existante. La syntaxe est la suivante :

CREATE [ UNIQUE ] INDEX index ON table (champ[, ...]) [WITH { PRIMARY | DISALLOW NULL | IGNORE NULL }]

• La clause UNIQUE permet de spécifier un index sans doublons. • La clause PRIMARY indique que l’index doit être la clé primaire de la table. Dans ce

cas, la clause UNIQUE est implicite. On ne peut spécifier qu’une seule clé primaire par table et Access génère une erreur si la table contient déjà une clé primaire.

• La clause DISALLOW NULL correspond à la clause standard NOT NULL, mais ne peut être spécifiée que lors de la création d’un index.

• La clause IGNORE NULL indique que les valeurs nulles doivent être ignorées dans la création de l’index.

3.5.3. Instruction ALTER TABLE Access SQL fournit l’instruction ALTER TABLE qui permet de modifier la structure d’une table existante. Elle permet deux choses :

• L’ajout et la suppression de colonnes. • L’ajout et la suppression d'index et de contraintes.

La syntaxe est la suivante :

ALTER TABLE table {ADD {COLUMN type de champ[(taille)] [CONSTRAINT index] I CONSTRAINT index_multichamp} | DROP {COLUMN champ I CONSTRAINT nom_d'index} }

Exemple d’ajout d’une colonne à la table CLIENT :

ALTER TABLE CLIENT ADD COLUMN col_sup MONEY;

Cette colonne peut ensuite être supprimée avec la requête :

ALTER TABLE CLIENT DROP COLUMN col_sup

L’instructions ALTER TABLE ne peut porter que sur un seul champ de la table concernée et il est impossible de supprimer un champ faisant partie d’un index. Dans ce cas, il faudra d’abord supprimer l’index à l’aide de la commande DROP INDEX.


sur 132

Il est également possible d’ajouter des contraintes d’intégrité référentielle sur des tables existantes en désignant un (ou des) champs comme clé(s) externe(s). On doit alors utiliser la clause ADD CONSTRAINT avec la même syntaxe que dans l’instructions CREATE TABLE. Par exemple, pour ajouter une relation "client_retrait" dans l’exemple de gestion simplifiée d’une banque, on écrira :

ALTER TABLE RETRAIT ADD CONSTRAINT client_retrait FOREIGN KEY (num_cli) REFERENCES CLIENT;

Dans le cas de l’ajout d’une contrainte sur une table contenant déjà des enregistrement s, Access vérifie que les données existantes respectent la nouvelle contrainte. Attention, cette opération peut être longue si la table contient un grand nombre d’enregistrement et Access refusera d’appliquer la contrainte si tous les tuples ne la respectent pas. 3.5.4. Instruction DROP L’instruction DROP, qui n’est pas dans la norme mais supportée par la majorités des SGBD commerciaux permet de supprimer une table ou un index. La syntaxe est la suivante :

DROP {TABLE table | INDEX index ON table} • Attention : Access ne demande aucune confirmation lors de l’exécution de cette

commande • Lors de la suppression d’une table, Access refusera l’exécution de la requête si la table

concernée fait partie d’une relation (respect de l’intégrité référentielle). Dans ce cas, il faudra d’abord supprimer la relation à l’aide de l’instruction "ALTER TABLE ... DROP CONSTRAINT ..."

3.6. Transact-SQL (T-SQL) T-SQL est le langage de programmation utilisé par SQL Server. C’est un sur-ensemble de ANSI-SQL 92, complété par des instructions de contrôle de flux. Son utilisation principale dans SQL Server est pour l’interrogation et la manipulation des bases de données à travers les vues ou les procédures stockées (CF chapitre 2), ainsi que pour l’automatisation de certaines tâches. Le code T-SQL peut être écrit depuis ISQL, Entreprise Manager de SQL Server, par ODBC (par exemple depuis Access) ou depuis Visual Studio. Les instructions se répartissent en 4 catégories : • Récupération et modification des données : SELECT, PRINT,INSERT, UPDATE, DELETE • Définition des données : CREATE TABLE, CREATE INDEX • Variables : DECLARE @x INTEGER • Contrôle de flux : IF..ELSE, WHILE, BEGIN… END, RETURN La plupart de ces notions sont présentées dans le chapitre 2 de cette notice. Elles sont appliquées lors de la présentation des vues et des procédures stockées dans SQL Server 7 ou MSDE.


sur 132

3.7. Liste des mots réservés Microsoft Access SQL La liste qui suit reprend tous les mots réservés par le moteur de base de données Microsoft Jet pour les utiliser dans des instructions SQL. Les mots de la liste qui ne sont pas entièrement en majuscules sont également réservés par Microsoft Access ou par Access Basic. Par conséquent, les rubriques d'aide individuelles pour ces mots donnent des descriptions générales qui ne portent pas principalement sur l'emploi de SQL. Remarque : Les mots suivis d'un astérisque (*) sont réservés par le moteur de base de données Jet, mais n'ont aucune signification dans le contexte d'une instruction SQL Microsoft Access (exemple : Level et TableID).

A

ABSOLUTE ANY ADD ARE ADMINDB AS ALL ASC Alphanumeric — Voir TEXT ASSERTION ALTER AUTHORIZATION ALTER TABLE AUTOINCREMENT — Voir COUNTER Avg AS

B-C

BEGIN COLLATION COLUMN BINARY COMMIT BIT COMP, COMPRESSION BIT_LENGTH CONNECT BOOLEAN — Voir BIT CONNECTION BOTH CONSTRAINT, CONSTRAINTS BY CONTAINER BYTE CONTAINS CASCADE CONVERT CATALOG Count CHAR, CHARACTER — Voir TEXT COUNTER CHAR_LENGTH CREATE CHARACTER_LENGTH CURRENCY CHECK CURRENT_DATE CLOSE CURRENT_TIME CLUSTERED CURRENT_TIMESTAMP COALESCE CURRENT_USER COLLATE CURSOR

D

DATABASE DISALLOW DATE — Voir DATETIME DISCONNECT DATETIME DISTINCT DAY DISTINCTROW DEC, DECIMAL DOMAIN DECLARE DOUBLE DELETE DROP DESC


sur 132

E-H

Eqv FOREIGN EXCLUSIVECONNECT FROM EXEC, EXECUTE FROM, clause EXISTS GENERAL — Voir LONGBINARY EXTRACT GRANT FALSE GROUP FETCH GUID FIRST HAVING FLOAT, FLOAT8 — Voir DOUBLE HOUR FLOAT4 — Voir SINGLE

I

IDENTITY INPUT IEEEDOUBLE — Voir DOUBLE INSENSITIVE IEEESINGLE — Voir SINGLE INSERT IGNORE INSERT INTO IMAGE INT, INTEGER, INTEGER4 — Voir LONG Imp INTEGER1 — Voir BYTE In INTEGER2 — Voir SHORT IN INTERVAL INDEX INTO INDEXCREATEDB Is INNER ISOLATION

J-M

JOIN LONGTEXT KEY LOWER LANGUAGE MATCH LAST Max LEFT MEMO — Voir LONGTEXT Level* Min Like MINUTE LOGICAL, LOGICAL1 — Voir BIT Mod LONG MONEY — Voir CURRENCY LONGBINARY MONTH LONGCHAR

N-P

NATIONAL Outer* NCHAR OUTPUT NONCLUSTERED OWNERACCESS Not PAD NTEXT PARAMETERS NULL PARTIAL NUMBER — Voir DOUBLE PASSWORD NUMERIC — Voir DOUBLE PERCENT NVARCHAR PIVOT OCTET_LENGTH POSITION OLEOBJECT — Voir LONGBINARY PRECISION ON PREPARE OPEN PRIMARY OPTION PRIVILEGES Or PROC, PROCEDURE ORDER PUBLIC

Q-S

REAL — Voir SINGLE SMALLDATETIME


sur 132

REFERENCES SMALLINT — Voir SHORT RESTRICT SMALLMONEY REVOKE SOME RIGHT SPACE ROLLBACK SQL SCHEMA SQLCODE, SQLERROR, SQLSTATE SECOND StDev SELECT StDevP SELECTSCHEMA STRING — Voir TEXT SELECTSECURITY SUBSTRING SET Sum SHORT SYSNAME SINGLE SYSTEM_USER SIZE

T-Z

TABLE UPDATEOWNER TableID* UPDATESECURITY TEMPORARY UPPER TEXT USAGE TIME — Voir DATETIME USER TIMESTAMP USING TIMEZONE_HOUR VALUE TIMEZONE_MINUTE VALUES TINYINT Var TO VARBINARY — Voir BINARY TOP VARCHAR — Voir TEXT TRAILING VarP TRANSACTION VARYING TRANSFORM VIEW TRANSLATE WHEN TRANSLATION WHENEVER TRIM WHERE TRUE WITH UNION WORK UNIQUE Xor UNIQUEIDENTIFIER YEAR UNKNOWN YESNO — Voir BIT UPDATE ZONE UPDATEIDENTITY

Utilisation de Access - epsic

Documents

Transcript of Utilisation de Access - epsic