CoursRepets CompilCOURS

Mon BORD « MonBTS » - Recueil de Cours Pour La Préparation Au BTS Filières IGL & GSI
République du Cameroun
Ministère de L’Enseignement Supérieur
Préparation Examen du BTS - Filières Informatiques (IGL / GSI)
Recueils de Cours Expliqués
1) Algorithmes Et Structures de Données Avancées ;
2) Base de Données Et Le Langage SQL ;
3) Analyse Informatique – MERISE ;
4) Analyse Informatique – Langage UML.
Proposé Par : Monsieur MINFOUNDI MANGUELE Wilfreed – 655 25 55 01 (Appels & Sms & WhatsApp)
Informaticien, Spécialiste des Prépas BTS (Taux de 100% Chaque Année Académique)
Mon BORD « MonBTS » - Proposé Par Monsieur Wilfreed MINFOUNDI Manguele - 655 25 55 01 1
Sommaire du Document
Sommaire du Document ..............................................................................................................................2
1. Cours 1 - Algorithmes Et Structures de Données Avancées .............................................................6
1.1. Généralités .....................................................................................................................................6
1.1.1. Structure Générale d’Un Algorithme : ....................................................................................6
1.1.2. La Notion de Types de Données ..............................................................................................6
1.1.3. La Notion de Variable .............................................................................................................7
1.1.4. La Notion de Constante ...........................................................................................................7
1.1.5. Les Opérateurs de Base ...........................................................................................................7
1.1.6. La Notion d’Affectation En Algorithme..................................................................................7
1.2. Les Instructions de Lecture Et d’Ecriture En Algorithme .......................................................8
1.2.1. Les Instructions de Lecture ......................................................................................................8
1.2.2. Les Instructions d’Ecriture ......................................................................................................8
1.3. Etapes de Résolution des Algorithmes ........................................................................................8
1.4. Les Structures Conditionnelles ....................................................................................................9
1.4.1. Structures Conditionnelles A Un Choix ..................................................................................9
1.4.2. Structures Conditionnelles A Deux Choix ..............................................................................9
1.5. La Notion des Boucles An Algorithme ......................................................................................10
1.5.1. La Boucle Pour . . . FinPour ..................................................................................................10
1.5.2. La Boucle TantQue . . .FinTantQue ......................................................................................11
1.5.3. La Boucle Répéter . . . Jusqu’à ..............................................................................................12
1.6. Les Enregistrements En Algorithme .........................................................................................13
1.6.1. Généralités Et Définition .......................................................................................................13
1.6.2. Exemple Et Explication .........................................................................................................13
1.6.3. Lecture Variable Type Enregistrement ..................................................................................14
1.6.4. Ecriture Variable Type Enregistrement .................................................................................14
1.7. Les Tableaux En Algorithme .....................................................................................................14
1.7.1. Définition des Variables Type Tableau .................................................................................14
1.7.3. Manipulations de Base Sur Le Type Tableau ........................................................................15
1.7.4. Algorithmes Type Tableau ....................................................................................................16
1.8. Les Tableaux d’Enregistrement Ou Vecteurs En Algorithme ................................................19
1.8.1. Généralités .............................................................................................................................19
1.9. Les Procédures Et Fonctions ......................................................................................................20
1.9.1. Généralités .............................................................................................................................20
1.9.2. Structure Générale de La Procédure ......................................................................................21
1.9.3. Structure Générale de La Fonction ........................................................................................21
1.9.4. Exemple d’Exercice Sur Les Procédures Et Fonctions .........................................................21
1.10. Les Principes En Algorithme .....................................................................................................23
1.10.1. Principe 1 – La Manipulation de La Variable Type Date ......................................................23
1.10.2. Principe 2 – Définition de La Structure de Données Dans Un Enoncé .................................24
1.10.3. Principe 3 – Enregistrer Les Eléments Dans Un Vecteur d’Enregistrement .........................24
1.10.4. Principe 4 - Parcourir Les Eléments d’Un Vecteur d’Enregistrement ..................................27
1.10.5. Principe 5 : Trier Les Eléments dans Un Vecteur .................................................................29
1.10.6. Identifier Les Paramètres Pour Un Sous – Programme .........................................................30
1.11. Les Structures de Données Avancées ........................................................................................31
1.11.1. Les Fichiers ............................................................................................................................31
1.11.2. Les Listes Chainées ...............................................................................................................32
2. Cours 2 – Base de Données Et Langage SQL Et Algèbre Relationnel ..........................................33
2.1. Généralités Sur Les Base de Données .......................................................................................33
2.2. Le Langage SQL..........................................................................................................................33
2.3. Les Commandes SQL .................................................................................................................33
2.4. Les Fonctions d’Agrégation En SQL ........................................................................................40
2.5. Autres Commandes En SQL ......................................................................................................41
2.6. La Notion de Jointure En SQL ..................................................................................................43
2.7. La Notion de Requête Imbriquée En SQL ...............................................................................44
2.8. Rappel des Commandes En SQL ..............................................................................................47
3. Cours 3 – Analyse Informatique – La Méthode d’Analyse MERISE ...........................................48
3.1. Généralités Sur La Méthode MERISE .....................................................................................48
3.2. Les Eléments de La Méthode MERISE ....................................................................................49
3.3. Le Modèle Conceptuel de Données ............................................................................................50
3.3.1. Les Règles de Gestion ...........................................................................................................50
3.3.2. Le Dictionnaire de Données ..................................................................................................50
3.3.3. Présentation des Concepts Liés Au MCD .............................................................................52
3.3.4. Etape de Réalisation du MCD ...............................................................................................52
3.4. Le Modèle Logique de Données .................................................................................................53
3.4.1. Généralités Sur Le MLD .......................................................................................................53
3.4.2. Règles de Passage du MCD Au Modèle Logique : ...............................................................53
4. Cours 4 - Analyse Informatique – Le Langage de Modélisation UML .........................................54
4.1. Généralités Sur Le Langage UML ............................................................................................54
4.2. Les Diagrammes UML................................................................................................................54
4.3. Le Diagramme des Cas d’Utilisation .........................................................................................55
4.3.1. Présentation Et Définition des Concepts ...............................................................................55
4.3.2. La Notion d’Acteur ................................................................................................................55
4.3.3. La Notion de Cas d’Utilisation ..............................................................................................56
4.3.4. Relations Entre Les Cas d’Utilisation....................................................................................56
4.3.5. Relation Entre Les Acteurs ....................................................................................................57
4.4. Le Diagramme de Classe ............................................................................................................57
4.4.1. Définition ...............................................................................................................................57
4.4.2. Schéma de La Classe .............................................................................................................57
4.4.3. Relations Entre Les Classe ....................................................................................................58
4.4.4. La Notion de Multiplicité ......................................................................................................59
4.4.5. Les Autres Types de Relation Entre Les Classes ..................................................................59
4.4.6. Exercice Récapitulatif ............................................................................................................62
4.4.7. Etapes de Mise En Place d’Un DDC .....................................................................................62
1. Cours 1 - Algorithmes Et Structures de Données Avancées :

1.1. Généralités :
Un algorithme est une suite finie et non ambiguë d'opérations ou d'instructions permettant de
résoudre un problème ou d'obtenir un résultat.
1.1.1. Structure Générale d’Un Algorithme :
Algorithme : Nom_Algorithme
Déclaration des Constantes
Définition des Types à Manipuler
Définition des Procédures et Fonctions
Déclaration des Variables
Début
Liste des Instructions
Fin.
NB : Le Nom_Algorithme Ou Le Nom des Variables Ne Doit Comporter Ni d’Espace, Ni

d’Accents, Ni de Caractères Spéciaux. Si Espace, Utiliser Le Caractère du Tiret de 8 (Chaine1_Chaine2).
1.1.2. La Notion de Types de Données :
A une variable est attribué un type. Ce type indique l'espace mémoire qui peut être réservé à cette
variable aussi bien d'un point de vu taille que contenu. Il existe des types simples qui sont prédéfinis tels
que : Le Type Entier ; Le Type Réel ; Le Type Chaine ou Chaine de Caractère (Pas de Différence En
Algorithme) ; Le Type Booléen (Type Qui Peut Avoir Comme Valeurs : Oui / NON, 0 / 1, Vrai / Faux).
1.1.3. La Notion de Variable :
Une variable est un emplacement mémoire ou un conteneur capable de contenir des valeurs de type
défini au préalable. Elle peut aussi être définie comme un Conteneur qui admet un nom, une taille, un
contenu (valeur) et une adresse. Le nom de la variable s'appelle "Identificateur de Variable". La taille
dépend du type de la variable (2Octets Pour Le Type Entier, 1Octet Pour Le Type Caractère, 4Octets Pour
Le Type Réel, ...etc.).
La déclaration d’une variable d’un certain type en Algorithme se fait par le mot clé « Var » et de la
manière suivante : Var Nom_Variable : Type de La Variable. Exemple : Var J : Chaine. Var Nbre : Entier.
Var Moyenne : Réel. Var Trouve : Booléen.
1.1.4. La Notion de Constante :
La définition d'une constante est identique à celle d'une variable, à la différence que la valeur d'une
constante, reste inchangée dans l'algorithme. Les constantes apparaissent dans un algorithme comme suit :
Const IdentificateurConstante = Valeur.
1.1.5. Les Opérateurs de Base :

 Les Opérateurs de Comparaison : Egalité (=) ; Différence (<> ou ≠) ; Strictement Inférieur (<) ;
Strictement Supérieur(>) ; Inférieur ou Egale (<=) ; Supérieur ou Egale (>=) ;
 Les Opérateurs Arithmétiques : Addition (+) ; Soustraction (-) ; Division (/) ; Multiplication (*) ;
 Les Autres Opérateurs :
o Div : Qui permet d’obtenir le quotient de la division de deux éléments de type entier. (Nbre1
Div Nbre2 ;
o Mod : Qui permet d’obtenir le reste de la division de deux éléments de type entier (Nbre1
Mod Nbre2).
1.1.6. La Notion d’Affectation En Algorithme :
C’est une instruction qui permet de ranger dans une variable une valeur conforme au type spécifié
lors de la déclaration des variables. Elle se présente par un signe et comporte deux parties : Une Expression
à Gauche qui est et sera toujours une variable Et Une Expression à Droite qui peut être une Valeur, une
Variable ou une combinaison de Variable et / ou Valeur.
1.2. Les Instructions de Lecture Et d’Ecriture En Algorithme :

1.2.1. Les Instructions de Lecture :
Une action de lecture permet à l'utilisateur d'introduire des informations pour effectuer un traitement
par l'ordinateur. En Algorithme l’instruction de lecture se fais par le mot clé Lire (). Exemple : Lire (Nbre).
Cette instruction permet de lire ou récupérer ou prendre la valeur de la variable Nbre entrée par un
utilisateur. NB : Lire (Identificateur Variable) Ou Lire (Liste Identificateurs Variables). Si Plusieurs Alors
Les Séparer Par Une Virgule. Exemple : Lire (Nbre1, Nbre2).
1.2.2. Les Instructions d’Ecriture :
Une action d'écriture permet d'afficher des résultats sur un périphérique de sortie (par défaut :
l'écran). En Algorithme l’instruction d’écriture se fais par le mot clé Ecrire (). Exemple : Ecrire (Nbre) =
permet d’écrire, afficher à l’écran la valeur de la variable Nbre.
NB : De manière générale, en Algorithme l’on distingue deux sortes de variables : Les Variables
d’Entrée Ou VE, qui sont des variables permettant d’aboutir au résultat de l’Algorithme et très souvent on
Lit Toujours Les VE. Nous avons aussi Les Variables de Sortie ou VS, qui représentent en fait le résultat
de l’Algorithme et très souvent on Affiche Toujours Les VS. En Résumé, J’ai Besoin de Lire Les VE
Pour Afficher Les VS.
1.3. Etapes de Résolution des Algorithmes :

 Etape 1 : Lire Et Relire L’Enoncé Afin de Mieux Comprendre Ce Qu’on Nous Demande (Nom de
l’Algorithme) ;
 Etape 2 : Identifier L’Ensemble des Variables (VE, VS). Déclaration des Variables. S’ils Sont du
même type, les déclarer sur une seule ligne en séparant par une virgule, sinon chaque type de
variable dois être sur sa ligne ;
 Etape 3 : Débuter l’Algorithme avec le mot clé « Début » et Commencez Par Les Lire Les VE (Lire
(Variable)) ;
 Etape 4 : Effectuer Les Calcules Ou Opérations afin d’aboutir au Résultat ;
 Etape 5 : Afficher La Valeur du Résultat (Ecrire (Variable)), Et Terminer L’Algorithme Avec Le
Mot Clé « Fin ».
1.4. Les Structures Conditionnelles :

1.4.1. Structures Conditionnelles A Un Choix :
Il s’agit d’un traitement qui ne peut s’exécuter que si une condition logique est satisfaite ; dans le
cas contraire, rien ne devrait se passer.
Si (Condition_Vérifiée) Alors
Instructions
FinSi.
Dans cette forme, la condition est évaluée. Si elle vaut vrai alors c'est la séquence d'actions qui est
exécutée sinon c'est l'action qui suit l'action conditionnelle dans l'algorithme qui est exécutée.
Explications :
 Une condition est une expression booléenne. Elle est soit vraie soit fausse et Fréquemment, cette
condition se présente sous forme de comparaison en utilisant les opérateurs : <, >, <=, >=, =, <> ;
 La condition est soit "simple", soit "composée". Dans le cas d'une condition composée (plusieurs
conditions à vérifier), vous utiliserez des opérateurs logiques et les plus utilisés sont : ET, OU ;
 Le traitement peut comporter une ou plusieurs instructions.
1.4.2. Structures Conditionnelles A Deux Choix :
La structure conditionnelle à deux choix est une structure algorithmique qui fait appel au maximum
à deux traitements.
Si (Condition_Vérifiée) Alors
Instructions_1
Sinon
Instructions_2
FinSi
Et Avec < Instructions_1> et < Instructions_2> pouvant être formé chacun d’une ou plusieurs
actions. Dans cette forme, la condition est évaluée. Si elle vaut vrai alors c'est la première séquence d'actions
qui est exécutée sinon c'est la deuxième qui est exécutée.
1.5. La Notion des Boucles An Algorithme :

1.5.1. La Boucle Pour . . . FinPour :
C’est une boucle qui permet de répéter un ensemble d’instructions un certain nombre de fois. Et ce
certain nombre de fois doit être et toujours connu à l’avance avant d’exécuter l’ensemble des instructions.
Pour Variable_Compteur = Variable_Initiale à Variable_Finale Faire
FinPour. Explication :
 Variable_Compteur : généralement i ou j, est la variable qui permet de compter le nombre

de tour d’exécution de la boucle ;
 Variable_Initiale : généralement et presque toujours fixé à 1, est la valeur initiale qui sera
affecté à la variable compteur au début de la boucle ;
 Variable_Finale : généralement et presque toujours représente le nombre maximal des

éléments à parcourir, est la valeur finale qui sera affecté à la variable compteur à la fin de la
boucle.
Exemple : Ecrire Un Algorithme Qui Lit Les Notes de 20 Etudiants.
Algorithme : Lecture
Var Note : Réel
i : Entier
Début
Pour i Allant de 1 à 20 Faire
Lire (Note)
FinPour.
Fin.
1.5.2. La Boucle TantQue . . .FinTantQue :
C’est une boucle qui permet de répéter un ensemble d’instructions jusqu’à un certain nombre
d’instruction.
Variable_Compteur Reçoit 1
TantQue (Variable_Compteur <=Max) Faire
Instructions
Variable_Compteur Reçoit (Variable_Compteur + 1)
FinTantQue.
Var Note : Réel
i : Entier
Début
i Reçoit 1
TantQue (i <=20) Faire
Lire (Note)
i Reçoit (i + 1)
FinTantQue.
Fin.
1.5.3. La Boucle Répéter . . . Jusqu’à :
C’est une boucle qui permet de répéter un ensemble d’instructions jusqu’à ce que certaines
conditions soient réalisées.
Variable_Compteur Reçoit 0
Répéter
Variable_Compteur Reçoit (Variable_Compteur + 1)
Instructions
Jusqu’à (Variable_Compteur = Max). Avec Max, Le Nombre Maximal des Eléments A

Parcourir.
Var Note : Réel
i : Entier
Début
i Reçoit 0
Répéter
i Reçoit (i + 1)
Lire (Note)
Jusqu’à (i = 20)
Fin.
1.6. Les Enregistrements En Algorithme :

1.6.1. Généralités Et Définition :
C’est un type de variable qui permet de regrouper sous un et unique nom plusieurs autres variables
de type différents mais faisant référence à un même objet à manipuler. Ce type de donné est définit par
l’utilisateur et permet de regrouper un nombre fini d’éléments appelé « Champ ». Les champs sont les
données élémentaires ou composées et peuvent être de type simple (Entier, Réel, Booléen, Chaine) ou de
type composé (faisant appel à d’autres types). La déclaration d’un type enregistrement se fait comme suit :
Type Nom_Type = Enregistrement
Nom_Champ_1 : Type_Champ_1
Nom_Champ_N : Type_Champ_N
Fin Enregistrement.
1.6.2. Exemple Et Explication :
Sois un étudiant caractérisé par son matricule, son nom, son âge et le libellé de sa filière, la définition
de ce type peut se faire de la manière suivante :
Type Etudiant = Enregistrement
MatricE : Chaine
NomE : Chaine
AgeE : Entier
Lib_Fil : Chaine
Fin Enregistrement.
Manipulations : En général on manipule un enregistrement champ par champ. On accède à un

champ de l'enregistrement en indiquant le nom de l'enregistrement suivi du nom du champ. Les deux sont
séparés par un point. (Variable_Enregistrement.Nom_Champ). En se basant sur l’exemple, on peut avoir :
 Etudiant.MatricE pour manipuler le champ matricule (MatricE) de la variable enregistrement

Etudiant ;
 Etudiant_AgeE pour manipuler le champ Age (AgeE) de la variable enregistrement Etudiant.
1.6.3. Lecture Variable Type Enregistrement :
La Lecture (Prendre, Récupérer) d’une variable de type enregistrement se fait champ par champ et
avec l’exemple précédent, on peut avoir :
 Lire (Etudiant.MatricE) : Pour Lire La Matricule de L’Etudiant ;
 Lire (Etudiant. NomE) : Pour Lire Le Nom de L’Etudiant ;
 Lire (Etudiant.AgeE) : Pour Lire L’Age de L’Etudiant ;
 Lire(Etudiant.Lib_Fil) : Pour Lire La Filière de L’Etudiant ;
1.6.4. Ecriture Variable Type Enregistrement :
L’Ecriture (Affichage à L’Ecran) d’une variable de type enregistrement se fait également champ
par champ et avec l’exemple précédent, on peut avoir :
 Ecrire (Etudiant.MatricE) : Pour Afficher La Matricule de L’Etudiant ;
 Ecrire (Etudiant. NomE) : Pour Afficher Le Nom de L’Etudiant ;
 Ecrire (Etudiant.AgeE) : Pour Afficher L’Age de L’Etudiant ;
 Ecrire (Etudiant.Lib_Fil) : Pour Afficher La Filière de L’Etudiant ;
1.7. Les Tableaux En Algorithme :

1.7.1. Définition des Variables Type Tableau :
Les Tableaux sont une structure de données abstrait ou types de données abstrait contenant plusieurs
emplacements mémoires de même type et qui sont repérés par des indices. Pour déclarer (définir), une
variable de type de tableau on écrit : Var Nom_Tableau = Tableau [Valeur_Min . .Valeur_Max] Type des
Eléments du Tableau.
Soit un tableau de 10 Entier, on va écrire : Var Toto = Tableau [1..10] Entier
La Définition d’Un Tableau de 10 Entier.
Indice 1 2 3 4 5 6 7 8 9 10
Valeur 17 5 67 87 9 14 11 32 21 47
 Toutes les valeurs du tableau ont le même type de données, Entier ;
 Chaque Elément du tableau est identifiable, repéré par une Valeur appelé indice ;
 Toto [1] = désigne le contenu (Valeur) de la Première Case du Tableau ;
 Toto [2] = désigne le contenu de la 2ième Case du Tableau ;
 Toto [n] = désigne le contenu de la nième Case du Tableau.
1.7.3. Manipulations de Base Sur Le Type Tableau :
Lecture (Prendre / Récupérer) des Eléments du Tableau :
Algorithme : Lecture_Tableau (Tableau de 10 Entier)
Var Toto = Tableau [1..10] Entier
i : Entier
Début
Lire (Toto[i])
FinPour
Fin.
Ecriture (Affichage) des Eléments du Tableau :
Algorithme : Ecriture_Tableau (Tableau de 10 Entier)
Var Toto = Tableau [1..10] Entier
i : Entier
Début
Ecrire (Toto[i])
FinPour
Fin.
1.7.4. Algorithmes Type Tableau :
Algorithme 1 – Rechercher Le Maximum Dans Un Tableau :
Le Principe de Ce Type d’Algorithme :
 Je Commence L’Algorithme Avec Le Nom de L’Algorithme, Je Déclare La Variable du Tableau,

Une Variable Max de Même Type Que Les Eléments du Tableau Et Une Variable Compteur i ;
 Je Débute L’Algorithme En Supposant Que La Variable Max Est Le Premier Elément du Tableau ;
 Et Quand Je Parcours Le Reste des Eléments du Tableau, Si Je Trouve Un Elément du Tableau Plus
Grand Que Mon Supposé Max Alors Je Permette Afin de d’Affecter à Max Sa Nouvelle Valeur ;
 Et A La Fin du Parcours du Tableau, La Variable Max Aura La Plus Grande Valeur du Tableau.
En Ecritures Algorithmiques, Sa Donne CECI :
Algorihme : RetrouverMax
Var Tab : Tableau [1..Nbre] Entier
Max, i : Entier
Début
Max Reçoit Tab [1]
Pour i Allant de 1 à Nbre Faire
Si (Tab[i] > Max) Alors
Max Reçoit Tab [i]
FinSi
FinPour
Ecrire (‘Le Maximum du Tableau Est :’, Max)
Fin
Algorithme 2 – Trier Les Eléments Dans Un Tableau :
Le Principe de Ce Type d’Algorithme Est Le Suivant :
 Je Commence L’Algorithme Avec Le Nom de L’Algorithme, Je Déclare La Variable du Tableau, 2

Variable de Type Compteur i Et j Et Une Variable Permut de Même Type Que Les Eléments du
Tableau ;
 Je Débute L’Algorithme En Parcourant La Première Boucle i de 1 à N – 1, Avec N, Le Nombre
Maximal des Eléments à Parcourir ;
 Ensuite dans La Deuxième Boucle, Je Dois Quitter de (i + 1) à N ;
 Et Je Place Ma Condition du Genre, Si Un Elément de i Est Supérieur à Un Elément de j, Alors Je
Permute Les Positions des Valeurs Afin D’Avoir Un Tableau Trié de Manière Croissante ;
 Je Ferme La Condition Et Les 2 Boucles Et Je Termine Mon Algorithme.
Algorihme : TrierTableau
Permut, i, j : Entier
Début
Pour i Allant de 1 à (N – 1) Faire
Pour j Allant de (i + 1) à N Faire
Si (Tab[i] > Tab[j]) Alors
Permut Reçoit Tab[i]
Tab[i] Reçoit Tab[j]
Tab[j] Reçoit Permut
FinSi
FinPour
FinPour
Fin
Algorithme 3 – Rechercher La Position d’Un Elément dans Un Tableau :
 Je Commence L’Algorithme Avec Le Nom de L’Algorithme, Je Déclare La Variable du Tableau,

Une Variable Pos Toujours de Type Entier, Une Variable Compteur i Et Une Variable Permettant
de Lire L’Elément Dont On Cherche Sa Position ;
 Je Débute L’Algorithme En Fixant Pos à – 1 Car Je Suppose Que L’Elément Ne Se Trouve Pas dans
le Tableau ;
 Je Parcours L’Ensemble des Eléments du Tableau Et Si Je Trouve Un Elément du Tableau = A
L’Elément à Chercher, Alors La Variable Pos Prends L’Indice de Cette Position ;
 Je Termine La Condition, La Boucle Et J’Affiche La Valeur de La Variable Pos Et Je Termine Mon
Algorithme ;
Algorihme : RetrouverPositionElement
Element, Pos, i : Entier
Début
Pos Reçoit – 1
Lire (‘Element’)
Si (Tab[i] = Element) Alors
Pos Reçoit i
FinSi
FinPour
Ecrire (‘La Position dans Le Tableau Est :’, Pos)
Fin
1.8. Les Tableaux d’Enregistrement Ou Vecteurs En Algorithme :

1.8.1. Généralités :
Il s’agit en fait d’un type de tableau contenant plusieurs variables pouvant être de type différents. Et
chaque élément de ce type de tableau est un enregistrement : d’où le nom de Tableau d’Enregistrement
encore appelé Vecteur. La définition de la variable tableau d’enregistrement ou vecteur commence toujours
et d’abord par la définition de la variable Enregistrement suivie de celle de la variable type tableau ou
vecteur.
Soit un étudiant donné par son matricule, son nom et sa filière. Définir un vecteur de 5 étudiants.
Type Etudiant = Enregistrement
MatricE : Chaine
NomE : Chaine
Fil_E : Chaine
Fin Enregistrement
Type Tab_Etd = Tableau [1..5] Etudiant
 Chaque Elément du Tableau Est de type Enregistrement : Etudiant ;
 On accède à un champ du tableau d'enregistrement en indiquant le nom de la variable vecteur ou

tableau d'enregistrement suivi crochet afin de préciser l’indice de l’élément à manipuler et on met
un point, et enfin du nom du champ. (Variable_Vecteur[i].Nom_Champ). En se basant sur
l’exemple, et qu’on note Var t : Tab_Etd,
o t[1].MatricE pour manipuler le matricule (MatricE) de l’étudiant se trouvant à la position 1

du vecteur ;
o t[3].Fil_E pour manipuler la filière de l’étudiant à la position 3 du vecteur d’enregistrement.
o De manière générale on dira t[i].Champ afin de manipuler le champ de l’enregistrement à la

positon i.
1.9. Les Procédures Et Fonctions :

1.9.1. Généralités :
Les procédures et fonctions sont des sous – programmes écris avant le programme principal mais
appelé depuis le programme principal. Les données dont a besoin les sous – programmes pour s’exécuter
sont appelés paramètres. Et lorsque le paramètre du sous – programme est susceptible d’être modifié, on
parlera de passage par adresse et la déclaration de ce type de paramètre est précédé du mot clé « var » (Var
t : Vecteur). Cette modifiions intervient généralement dans deux cas de figures (le cas de l’enregistrement
dans le vecteur ou le tri dans un vecteur). Par contre, lorsque le paramètre n’est pas susceptible d’être
modifie, on parlera de passage par valeur (pas de mot clé var devant la variable). Contrairement aux
procédures, les fonctions sont des sous – programmes qui renvoient toujours un résultat et ce résultat doit
être de type simple (Entier, Réel, Booléen).
1.9.2. Structure Générale de La Procédure :
Procédure Nom_Procedure (Param1 : Type ; Param2 : Type)
Var (Déclaration des Variables Locales)
Début
Fin Procédure.
1.9.3. Structure Générale de La Fonction :
Fonction Nom_Fonction (Param1 : Type ; Param2 : Type) :Type_Retour (de La Fonction)
Var (Déclaration des Variables Locales)
Début
Nom_Fonction Reçoit Résultat (Ou Ecrire Retourner (Résultat))
Fin Fonction.
1.9.4. Exemple d’Exercice Sur Les Procédures Et Fonctions :
Enoncé : Ecrire Un Algorithme, Une Procédure Et Une Fonction Qui Calcule Le Factoriel d’Un
Nombre Entré Au Clavier.
Solution :
Algorithme : Calcul_Facotiel
Var Fact, i, Nbre : Entier
Début
Ecrire (‘Entrez Le Nombre Entier’)
Lire (Nbre)
Fact Reçoit 1
Fact Reçoit (Fact * i)
FinPour
Ecrire (Fact)
Fin
Procédure Calcul_Facotiel (Nbre : Entier)
Var i, Fact : Entier
Début
Lire (Nbre)
Fact Reçoit 1
FinPour
Ecrire (Fact)
Fin
Fonction CalculFacotiel (Nbre : Entier)
Var i, Fact : Entier
Début
Lire (Nbre)
Fact Reçoit 1
FinPour
CalculFacotiel Reçoit Fact Ou Alors Retourner (Fact)
Fin
1.10. Les Principes En Algorithme :
L'algorithmique est l'ensemble des principes, règles et techniques qui permettent d'écrire un
algorithme. Pour concevoir un programme informatique, on utilise le plus souvent le pseudocode. Une
variable permet de mémoriser et de manipuler des données.
1.10.1. Principe 1 – La Manipulation de La Variable Type Date :
Si dans l’énoncé on manipulera une Variable de Type Date (Date Commande, Date Livraison, Date
de Naissance, Date Inscription, Date Etc) Alors, Définir Le Type Date Comme Premier Type dans La
Définition de La Structure de Données. Et de La Manière Suivante :
Type Date = Enregistrement
Jour : Entier
Mois : Entier
An : Entier
Fin Enregistrement
Exemple : Var MaDate : Date, Et Dans Les Ecritures, On Peut Ecrire
 MaDate.Jour = Pour Manipuler Le Champ Jour de La Variable MaDate ;

 MaDate.Mois = Pour Manipuler Le Champ Mois de La Variable MaDate ;
 MaDate.An = Pour Manipuler Le Champ An de La Variable MaDate.
1.10.2. Principe 2 – Définition de La Structure de Données Dans Un

Enoncé :
Dans Un Enoncé, Définir La Structure de Données Reviens Tout Simplement Définir L’Ensemble
des Types A Manipuler Suivant L’Ordre :
o Type 1 : Le Type Date Si Variable Date A Manipuler (Sinon Passer Au Type Suivant) ;
o Type 2 : Le Type Enregistrement (Se Poser La Question, On Gère Ou Manipuler Quoi.

La Réponse A Cette Question Déterminera La Type A Définir ;
o Type 3 : La Variable Type Tableau Ou Vecteur d’Enregistrement ;
o Type 4 : La Variable Type Fichier ;
o Type 5 : La Variable Type Liste Chainée.
1.10.3. Principe 3 - Enregistrer Ou Sauvegarder Les Eléments Dans Un

Vecteur d’Enregistrement :
o Cas 1 : Enregistrer TOUT : On Suppose Que Le Vecteur Est Vide Et Donc Faut Le
Remplir Donc Je Fais PLE = Je Parcours Tout + Je Lis Chaque Et J’Enregistre :
Je Déclare Var Tab : Vecteur_Enregistrement, E : Enregistrement, i : Entier
Je Débute L’Algorithme
Je Parcours Tous Les Eléments (Pour i Allant de 1 à Max Faire)
Pour Chaque Pas de i, Je Lis Tous Les Champs (Lire E.Champ1) Jusqu’à E.ChampN
Apres Le Parcours, Sur Chaque Elément Lu, J’Enregistre A La Position i du Vecteur (Tab[i]
Reçoit E
Procédure Enregistrer_TOUT (Var Tab : VecteurEnregistrement)
Var i : Entier
E : Enregistrement
Début
Pour i Allant de 1 à Max Faire
Lire (E.Champ) //Je Dois Lire Tours Les Champs
Tab[i] Reçoit E
Fin Procédure
o Cas 2 : Enregistrer UN Seul, Ici On Suppose Que Le Vecteur N’Est Pas Vide Et Peut
Etre Pas Plein Et Donc Je Fais VLIE = Je Vérifie + Je Lis L’Elément + J’Incrémente
Et J’Enregistre :
Je Déclare Var Tab : Vecteur_Enregistrement, E : Enregistrement
Je Teste Si Le Vecteur Est Plein (Si N = Max) Alors Ecrire (Vecteur Plein)
Sinon
Je Lis Tous Les Champs (Lire E.Champ1) Jusqu’à E.ChampN
J’Incrémente Nouvelle Position (N Reçoit (N +1))
J’Enregistre à La Position i du Vecteur (Tab [i] Reçoit E)
Procédure Enregistrer_UnSeulElement (Var Tab : VecteurEnregistrement ; Nbre : Entier)
Var E : Enregistrement
Début
Si (Nbre = Max) Alors
Ecrire (‘Le Vecteur Est Plein.’)
Sinon
Nbre Reçoit (Nbre + 1)
Tab [Nbre] Reçoit E
FinSi
Fin Procédure
o Cas 3 : Enregistrer Plusieurs : Ici, Non Seulement Le Vecteur N’Est Pas Plein Mais Je
Dois Aussi Vérifier Si Il Existe Encore Suffisamment d’Espace Pour Les Plusieurs
Eléments Et Donc Je Vais VVPLIE = Je Vérifie + Je Vérifie + Je Parcours + Je Lis +
J’Incrémente Et J’Enregistre :
Je Déclare Var Tab : Vecteur_Enregistrement, E : Enregistrement, i Et M : Entier
Je Teste Si Vecteur Plein (Si N = Max) Alors Ecrire (Vecteur Plein)
Sinon
Je Vérifie Si Encore Assez D’Espace (Si Max – N >=M) Alors
Je Parcours M Eléments (Pour i Allant de 1 à M) Faire
Je Lis Tous Champs (Lire E.Champ1) Jusqu’à E.ChampN
J’Incrémente Nouvelle Position (N Reçoit (N +1))
J’Enregistre à La Position i du Vecteur (Tab [i] Reçoit E
Sinon
Je Dis Ecrire (‘Pas Assez Espace’)
Procédure EnregistrerPlusieurs (Var Tab : VecteurEnregistrement ; Nbre : Entier)
Var i, M : Entier
E : Enregistrement
Début
Si (Nbre = Max) Alors
Ecrire (‘Le Vecteur Est Plein.’)
Sinon
Si (Nbre + M < = Max) Alors
Pour i Allant de 1 à M Faire
Nbre Reçoit (Nbre + 1)
Tab [Nbre] Reçoit E
FinPour
Sinon
Ecrire (‘Pas Suffisamment d’Espace dans Le Vecteur’)
FinSi
FinSi
Fin Procédure
1.10.4. Principe 4 - Parcourir Les Eléments d’Un Vecteur

d’Enregistrement :
o Pour Afficher Certains Eléments : Et Dans Ce Cas :
 Je Parcours : Pour i Allant de 1 à N Faire ;
 Je Précise La Condition : Si Tab [i].Champ = Valeur (Condition Pour Aboutir Au

Résultat)
 Et J’Afficher Le Résultat Qui Doit Etre Le Premier Et 2ième Champ de La Variable

Enregistrement Ecrire (Tab [i].Champ1) Et Ecrire (Tab [i].Champ2)
Procédure PCR_Afficher (Tab : VecteurEnregistrement ; ConditionParametre : Type)
Var i : Entier
ConditionValeurLue : Type
Début
Si (Tab[i].Champ = ConditionParametre Ou ConditionValeurLue) Alors
Ecrire (Tab[i].Champ1)
Ecrire (Tab[i].Champ2)
FinSi
FinPour
Fin Procédure
o Pour Compter Le Nombre de Fois Que La Condition Est Vérifiée : Et Dans Ce Cas :
 Je Déclarer Une Variable Cpt de Type Entier ;
 Je Débute L’Algorithme En Initialisant Cpt à 0 (Cpt Reçoit 0) ;
 Je Parcours : Pour i Allant de 1 à N Faire ;
 Je Précise La Condition : Si Tab [i].Champ = Valeur (Condition Pour Aboutir Au

Résultat) ;
 Et A L’intérieur de La Boucle Et A Chaque Vérification du Si J’Incrémente La

Valeur de Cpt (Cpt Reçoit Cpt + 1))
Procédure PCR_Compter (Tab : VecteurEnregistrement ; ConditionParametre : Type)
Var Cpt, i : Entier
ConditionValeurLue : Type
Début
Cpt Reçoit 0
Si (Tab[i].Champ = ConditionParametre Ou ConditionValeurLue) Alors
Cpt Reçoit (Cpt + 1)
FinSi
FinPour
Ecrire (Cpt)
Fin Procédure
1.10.5. Principe 5 : Trier Les Eléments dans Un Vecteur :
o Je Déclare Var Tab : Vecteur_Enregistrement, Permut : Enregistrement, i Et j : Entier ;
o Je Début L’Algorithme :
Si Tab [i].Champ_Trie > Tab [j].Champ_Trie Alors
Permut Reçoit Tab [i]
Tab [i] Reçoit t[j]
Tab [j] Reçoit Permut
Procédure TrieVecteur (Var Tab : VectEnregistrement)
Var Permut : Enregistrement
i, j : Entier
Début
Si (Tab[i].ChampTrie > Tab[j].ChampTrie) Alors
Permut Reçoit Tab[i]
Tab[i] Reçoit Tab[j]
Tab[j] Reçoit Permut
FinSi
FinPour
FinPour
Fin Procédure
1.10.6. Identifier Les Paramètres Pour Un Sous – Programme :
o Ecrire Un Sous – Programme Qui Prend En Entrée,
o Ecrire Un Sous – Programme Qui Prend En Paramètre,
o Ecrire Un Sous – Programme Qui Etant Donnée Tel Ou Tel Champ,
Généralement Ce Qui Suit Ces Phrases Représentera Le Paramètre Dont A Besoin Le Sous –
Programme Pour s’exécuter. En D’Autres Termes, Si Je Dois Manipuler Un Enregistrement La Question
A Poser Est La Suivante, L’Enregistrement Est Stocké Dans Quoi ? La Réponse A Cette Question
Représente Le Premier Paramètre du Sous – Programme.
1.11. Les Structures de Données Avancées :

1.11.1. Les Fichiers :
1.11.1.1. Généralités Sur Les Fichiers :
1.11.1.2. Manipulation des Primitives de Base Sur Les Fichiers :
Ouvrir Un Fichier En Mode Lecture :
Ouvrir Un Fichier En Mode Ecriture :
Ouvrir Un Fichier En Mode Lecture Et Ecriture :
Fermer Un Fichier :
Traitement Sur Les Fichier En Mode Lecture :
Traitement Sur les Fichiers En Mode Ecriture :
1.11.1.3. Les Algorithmes Type Sur Les Fichiers :
Parcourir Les Eléments d’Un Fichier Pour Afficher :
Parcourir Les Eléments d’Un Fichier Pour Compter :
Créer Ou Enregistrer Les Eléments d’Un Fichier :
Calculer La Taille d’Un Fichier :
1.11.1.4. Les Algorithmes de Transfert Sur Les Fichiers :
Transférer Les Eléments du Vecteur Dans Le Fichier :
Transférer Les Eléments du Fichier Dans Un Vecteur :
Trier Les Eléments d’Un Fichier :
1.11.2. Les Listes Chainées :

1.11.2.1. Généralités Sur Les Listes Chainées :
1.11.2.2. Liste des Procédures d’Utilisation des Listes Chainées :
1.11.2.3. Différence Entre Liste Chainée, Les Piles Et Les Files :
1.11.2.4. Déclaration de La Variable de Type Liste Chainée :
1.11.2.5. Manipulations de La Variable de Type Liste Chainée :
1.11.2.6. Créer Une Liste Chainée A Un Elément ;
1.11.2.7. Créer Une Liste Chainée A Plusieurs Eléments :
1.11.2.8. Calculer La Taille d’Une Liste Chainée :
1.11.2.9. Quelques Algorithmes Type Sur Les Liste Chainées :
Procédure Insertion En Tête Dans Une Liste Chainée :
Procédure Insertion En Queue Dans Une Liste Chainée :
Supprimer Le Premier Elément de La Liste Chainée :
Supprimer Le Dernier Elément de La Liste Chainée :
Parcourir Une Liste Chainée Pour Afficher Certains Champs :
Parcourir Une Liste Chainée Pour Compter Le Nombre d’Eléments Respectant La Condition :
2. Cours 2 – Base de Données Et Langage SQL Et Algèbre Relationnel

2.1. Généralités Sur Les Base de Données :
Une Base de Données en abréviation BDD ou en anglais Data Base (DB) est une entité dans laquelle
il est possible de stocker de façon structuré avec le moins de redondance possibles. Autrement dit, une base
donnée peut être considérée comme un ensemble de données accessibles et exploitables au moyen d’un
ensemble de programmes. Et ce programme est appelé Système de gestion de Bases de Données ou SGBD
qui est en fait un outil logiciel permettant d’accéder à des bases de données. Comme Exemple de SGBD,
on peut citer Oracle, MySQL, Microsoft SQL Server, Sybase, Informix, Paradox, PostgreSQL, Etc. La
gestion et l’accès à une base de données sont assurés par un ensemble de programmes qui constituent le
Système de gestion de base de données (SGBD). Un SGBD doit permettre l’ajout, la modification et la
recherche de données. Un système de gestion de bases de données héberge généralement plusieurs bases
de données, qui sont destinées à des logiciels ou des thématiques différentes. Et Actuellement, la plupart
des SGBD fonctionnent selon un mode client/serveur. Le serveur (sous - entendu la machine qui stocke les
données) reçoit des requêtes de plusieurs clients.
2.2. Le Langage SQL :
SQL, Structured Query Language, est un langage d’interrogation de données permettant de

communiquer avec une base de données. Le langage SQL a été initialement développé par IBM à San José.
D’abord baptisé SEQUEL, il est devenu le standard pour décrire et manipuler les bases relationnelles depuis
1986. A cette date, une première version a été normalisée sous le nom de SQL1. Depuis, d'autres versions
normalisées de SQL ont été produites. Ainsi, en 1992, une version étendue appelée SQL2, puis en 1998
une version très étendue baptisée SQL3. Le SQL permet de remplir 5 rôles : La recherche de données ; La
définition des données (Langage de Définition de Données, LDD = Création de Tables + Contraintes
Intégrité + Modification de Tables) ; La modification des données (Langage de Modification de Données,
LMD = Sélection + Tri + Regroupement + Jointure des données) ; Le Contrôle des données (Langage de
Contrôle des Données, LCD) ; Le Contrôle de la Concurrence d’accès aux donnée.
2.3. Les Commandes SQL :
NB : Une Commande, Une Fonction SQL Sont Toujours En Majuscule. TOUJOURS.
 Créer Une Base de Données : SQL CREATE DATABASE, cette commande permet de créer une
base de données dans le SGBD manipulé. Syntaxe : CREATE DATABASE NomBase ; Exemple :
CREATE DATABASE IPES2020 ;
 Créer Les Tables Dans Une Base de Données : SQL CREATE TABLE, cette commande SQL
permet de créer une table. La création d’une table permet de définir les colonnes et les types de
données qui seront contenus dans chacune des colonnes. Syntaxe : CREATE TABLE NomTable (
Colonne1 : Type (Taille) Contraintes,
Colonne2 : Type,
ColonneN : Type
);
NB : Chaque Ligne se termine par une virgule sans l’avant dernière qui ne doit pas comporter de
virgule à la fin de la ligne. Concernant :
Les Types de Données, on peut citer (les plus usuels, utilisés) : Entier = INT ; Chaine de Caractère
= VARCHAR et la taille est obligatoire ; Caractère = CHAR ; Date = DATE ; Heure = TIME ; Réel =
DOUBLE ou DECIMAL (N,M) avec M le nombre de chiffre après la virgule de la décimal ; Booléen =
BOOLEAN ;
Les Contraintes : NOT NULL : qui empêche d’enregistrer une valeur nulle dans cette colonne.
Cette contrainte est OBLIGATOIRE sur la clé primaire ; DEFAULT : qui attribue une valeur par défaut à
cette colonne lors de l’ajout d’une nouvelle ligne dans la table ; PRIMARY KEY : qui indique que cette
colonne est considérée comme clé primaire ; FOREIGN KEY : qui précise si cette colonne est une clé
étrangère ou clé migratoire ou clé secondaire.
Exemple : Soit Le Modèle Relationnel :
FOURNISSEUR (CodeFour, NomFour, AdresseFour)
PRODUIT (RefereceProd, LibelléProd, Date_Approv, QteStock, #CodeFour)
NB : Dans Un Schéma Relationnel, lorsque le nom de l’attribut est précédé du signe #, cela signifie
que cette attribue est considéré comme clé migratoire donc clé étrangère et de manière générale, c’est
souvent le nom de l’attribut principal d’autre autre relation qui a migré.
Solution Exemple :
CREATE TABLE FOURNISSEUR (
CodeFour : VARCHAR (10) PRIMARY KEY NOT NULL,
NomFour : VARCHAR (50),
AdresseFour : VARCHAR (50) DEFAULT ‘‘YAOUNDE’’
);
CREATE TABLE PRODUIT (
ReferenceProd : VARCHAR (10) PRIMARY KEY NOT NULL,
LibelléProd : VARCHAR (50),
Date_Approv : DATE,
QteStock : INT,
CodeFour : VARCHAR (10),
FOREIGN KEY (CodeFour) REFERENCES FOURNISSEUR (CodeFour)
);
NB : Lors de la création d’une table où se trouve une ou des clés étrangères, Créer déjà et d’abord
dans un premier temps, l’attribut en bonne forme mais en respectant le même type et taille tel que définit
sur la clé primaire et ensuite précisez que c’est une clé migratoire avec le mot clé FOREIGN KEY ;
 Afin d’Uniformisez (avoir la même manière à chaque fois) les tailles de vos types de données
VARCHAR :
o Si la clé primaire est un VARCHAR, Alors Je Fixe La Taille soit à 5 ou à 10 ;
o Si un attribut est un VARCHAR, alors Je Fixe La Taille à 25 ou 50 ou 100 ;
 Supprimer Une Base de Données : DROP DATABASE, cette commande permet de supprimer la
base de données et tout ce qu’elle contient. Syntaxe : DROP DATABASE Nom_Base ;
 Supprimer La Table Dans Une Base de Données : DROP TABLE, cette commande SQL permet
de supprimer la table dans la base de données. Syntaxe : DROP TABLE Nom_Table ;
 Modifier La Structure d’Une Base de Données : ALTER TABLE : qui permet de modifier une
table existante. Et dans cette commande SQL, il est possible d’ajouter une nouvelle colonne, de
supprimer une colonne existante dans la table, de changer le type de données de la colonne dans une
table et de renommer le libellé d’une colonne.
Syntaxe : ALTER TABLE Nom_Table
Instructions ;
Ajouter Une Colonne :
ALTER TABLE Nom_Table
ADD Nom_Colonne : Type (Taille) Contraintes ;
Supprimer Une Colonne : ALTER TABLE Nom_Table DROP COLUMN Nom_Colonne ;
Modifier Le Type de Données : ALTER TABLE NomColonne MODIFY NomColonne : Type

(Taille) Contraintes ;
Renommer Une Colonne : ALTER TABLE Nom_Table RENAME COLUMN Ancien_Nom TO

Nouveau_Nom ;
 Supprimer Les Données dans Une Table : SQL TRUNCATE TABLE, cette commande SQL
permet de supprimer les données dans une table sans supprimer la table elle-même. Autrement dit,
cette commande vide la table. Syntaxe : TRUNCATE TABLE Nom_Table ;
 Sélection des Données dans Une Table :
SQL SELECT, cette commande SQL consiste à lire les données issues de la base de données. Cette
commande SQL retourne les enregistrements dans un tableau de résultat. Elle peut sélectionner plusieurs
colonnes provenant de plusieurs tables : on parlera alors de jointures.
Syntaxe : SELECT Nom_Colonne1, Nom_Colonne2
FROM Nom_Table ;
NB : Nom_Colonne (Nom_Colonne1, ou Nom_Colonne2)= représente le nom de la colonne à

afficher, à donner en résultat de la dite requête.
FROM Nom_Table, c’est pour préciser source de la colonne autrement dit le nom de la Table de la
base de données.
NB : Il est possible de retourner automatiquement toutes les colonnes d’une table sans avoir à
connaitre le nom des colonnes, on utilise alors le caractère * (Joker) et qui permet de sélectionner toutes les
colonnes de la table. Et dans ce cas, on écrit : SELECT *
FROM CLIENT ;
NB : A chaque fois qu’on parlera de donner ou d’afficher une liste d’informations, il sera très
souvent question de penser au caractère Joker devant le mot clé SELECT. Mais si on précise la colonne,
alors préciser la colonne.
 Syntaxe Globale de La Commande SELECT :
SELECT * FROM Nom_Table
WHERE Conditions
GROUPE BY
HAVING Conditions
ORDER BY Expressions
 Le Mot Clé DISTINCT : Ce mot clé est utilisé après le mot clé SELECT et permet d’éviter les
redondances dans les résultats d’une requête. Syntaxe :
SELECT DISTINCT Nom_Colonne
FROM Nom_Table ;
 Le Mot Clé WHERE : Le mot clé WHERE dans une requête SQL permet d’extraire les lignes
d’une base de données respectant la condition. Elle permet ainsi d’obtenir uniquement les lignes
désirées. Syntaxe :
SELECT Nom_Colonn
FROM Nom_Table WHERE Conditions ;
 La Notion des Opérateurs En SQL : En termes d’opérateurs, on peut en citer AND (ET, qui
permet de combiner 2 Conditions où les 2 Conditions doivent être respectées. Condition1 Et
Condition2), OR (Ou, qui permet de combiner 2 Conditions où l’une des 2 Conditions doit être
respectée. Condition1 Ou Condition2) ou l’opérateur BETWEEN et ces opérateurs peuvent être
utilisés dans la requête SQL sur le mot clé WHERE.
Syntaxe 1 : SELECT Nom_Colonne
FROM Nom_Table
WHERE Condition_1 AND Condition_2 ;
Syntaxe 2 : SELECT Nom_Colonne
FROM Nom_Table
WHERE Condition_1 OR Condition_2 ;
 Opérateur BETWEEN : il est utilisé pour sélectionner un intervalle de donnée dans une requête
SQL utilisant le mot clé WHERE. Syntaxe :
SELECT Nom_Colonne
FROM Nom_Table
WHERE Colonne1 BETWEEN Valeur1 AND Valeur2 ;
 La Notion de Recherche En SQL : En SQL, la recherche est possible avec l’utilisation du mot Clé
LIKE qui permet d’effectuer une recherche sur un modèle particulier. Syntaxe : SELECT
Nom_Colonne FROM Nom_Table WHERE Nom_Colonne LIKE Modèle. S’agissant du modèle à
rechercher, on a :
o LIKE ‘‘%A’’ : NB, le caractère % est un caractère Joker qui renvoie toutes les chaines de
caractères. Donc sur ce modèle en particulier permet de rechercher les chaines se terminant
par un ‘‘A’’ ;
o LIKE ‘‘A%’’ : qui renvoie toutes les chaines de caractère commençant par un ‘‘A’’ ;
o LIKE ‘‘%A%’’ : qui renvoie toutes les chaines de caractère contenant un ‘‘A’’.
 La Notion de Trie En SQL : La commande ORDER BY permet de trier les lignes dans un résultat
d’une requête SQL. Il est possible de trier les données sur une ou plusieurs colonnes, par ordre
ascendant ou croissant (ORDER BY ASC) ou descendant ou décroissant (ORDER BY DESC).
Syntaxe :
SELECT Nom_Colonne
FROM Nom_Table
WHERE Conditions ORDER BY Nom_Colonne (DESC, ASC) ;
 La Notion de Regroupement de Données En SQL : La commande GROUP BY est utilisée en

SQL pour grouper plusieurs résultats et utiliser une fonction de totaux sur un groupe de résultat. Sur
une table qui contient toutes les ventes d’un magasin, il est par exemple possible de lister et
regrouper les ventes par clients. Donc autrement dit à chaque fois dans une requête qu’on parlera
des termes suivant, faudra pensez à un regroupement de données : Liste des Informations Par, Pour
Chaque Information. Syntaxe :
SELECT Nom_Colonne
FROM Nom_Table
WHERE Conditions GROUP BY Nom_Colonne ;
2.4. Les Fonctions d’Agrégation En SQL :
o La Valeur Moyenne : La fonction d’agrégation AVG () dans le langage SQL permet de

calculer une valeur moyenne sur un ensemble d’enregistrement de type numérique.
Syntaxe : SELECT Nom_Colonne1, AVG (Nom_Colonne2)
FROM Nom_Table
WHERE Conditions ;
o Compter Les Lignes d’Enregistrement : En SQL, la fonction d’agrégation COUNT ()

permet de compter le nombre d’enregistrement dans une table. Connaître le nombre de lignes
dans une table est très pratique dans de nombreux cas, par exemple pour savoir combien
d’utilisateurs sont présents dans une table ou pour connaître le nombre de commentaires sur
un article. Syntaxe : SELECT COUNT (*) FROM Nom_Table WHERE Conditions ;
o Récupérer La Valeur Maximale (Minimale) : Dans le langage SQL, la fonction

d’agrégation MAX () permet de retourner la valeur maximale d’une colonne dans un jeu
d’enregistrement. La fonction peut s’appliquée à des données numériques ou
alphanumériques. Il est par exemple possible de rechercher le produit le plus cher dans une
table d’une boutique en ligne.
Syntaxe1 : SELECT Nom_Colonne1, MAX (Nom_Colonne2)
FROM Nom_Table
WHERE Conditions ;
o Sommer, Additionner Les Valeur dans Une Colonne : Dans le langage SQL, la fonction
d’agrégation SUM () permet de calculer la somme totale d’une colonne contenant des
valeurs numériques. Cette fonction ne fonctionne que sur des colonnes de types numériques
(INT, FLOAT, DOUBLE …) et n’additionne pas les valeurs NULL. ). Syntaxe :
SELECT SUM (Nom_Colonne)
FROM Nom_Table
WHERE Conditions ;
o Insérer Une Condition Dans Une Fonction SQL : La condition HAVING en SQL est
presque similaire à WHERE à la seule différence que HAVING permet de filtrer en utilisant
des fonctions telles que SUM (), COUNT (), AVG (), MIN () ou MAX ().
Syntaxe : SELECT Nom_Colonne1, Fonction (Nom_Colonne2)
FROM Nom_Table
GROUP BY Nom_Colonne1
HAVING Fonction (Nom_Colonne2) Opérateur Valeur ;
NB : Opérateur (=, <, >, <=, >=) et Valeur représente la Valeur de comparaison de la requête. Cela
permet donc de sélectionner les colonnes de la table “Nom_Table” en groupant les lignes qui ont des valeurs
identiques sur la colonne “Nom_Colonne1” et que la condition de HAVING soit respectée. NB : HAVING
est très souvent utilisé en même temps que GROUP BY bien que ce ne soit pas obligatoire.
2.5. Autres Commandes En SQL :

 Ajouter Les Données Dans Une Table : L’insertion de données dans une table s’effectue à l’aide
de la commande INSERT INTO. Cette commande permet au choix d’inclure une seule ligne à la
base existante ou plusieurs lignes d’un coup. Pour insérer des données dans une base, il y a 2
syntaxes principales : Insérer une ligne en indiquant les informations pour chaque colonne existante
(en respectant l’ordre) ou Insérer une ligne en spécifiant les colonnes que vous souhaitez compléter.
Il est possible d’insérer une ligne renseignant seulement une partie des colonnes ;
Syntaxe1 : INSERT INTO Nom_Table (
Nom_Colonne1, Nom_Colonne2, Nom_ColonneN)
VALUES (Valeur1, Valeur2, ValeurN) ;
Il est possible d’ajouter plusieurs lignes à un tableau avec une seule requête. Pour ce faire, il convient
d’utiliser la syntaxe suivante : Syntaxe2 :
INSERT INTO Nom_Table (Nom_Colonne1, Nom_Colonne2, Nom_ColonneN)
VALUES (Valeur1, Valeur2, ValeurN),
(Valeur11, Valeur22, ValeurNN),
(Valeur111, Valeur222, ValeurNNN) ;
NB : Lorsque le champ à remplir est de type VARCHAR ou TEXT il faut indiquer le texte entre
guillemet simple ou double côte. En revanche, lorsque la colonne est un numérique tel que INT ou BIGINT
il n’y a pas besoin d’utiliser de guillemet, il suffit juste d’indiquer le nombre ou la valeur précise. Mais par
contre si le champ est du type alors, indiquer de la façon suivante : ‘‘#JJ/MM/AAAA#’’
 Modifier Les Valeurs, Données Dans Une Table : La commande UPDATE permet en SQL
d’effectuer des modifications sur des lignes existantes. Très souvent cette commande est utilisée
avec WHERE pour spécifier sur quelles lignes doivent porter la ou les modifications. Syntaxe :
UPDATE Nom_Table
SET Nom_Colonne = ‘‘Nouvelle_Valeur’’
WHERE Conditions ;
 Supprimer Les Lignes de Données Dans Une Table :
La commande SQL DELETE est utilisée pour supprimer les enregistrements existants d'une table.
Vous pouvez utiliser la clause WHERE avec une requête DELETE pour supprimer les lignes sélectionnées,
sinon tous les enregistrements seraient supprimés. Syntaxe : DELETE FROM Nom_Table WHERE
Conditions. NB : S’il n’y a pas de condition WHERE alors Toutes les lignes seront supprimées et la table
sera alors vide.
2.6. La Notion de Jointure En SQL :
 La Notion d’Alias : Dans le langage SQL, il est possible d’utiliser des Alias pour renommer
temporairement une colonne ou une table dans une requête. Cette astuce est particulièrement utile
pour faciliter la lecture des requêtes :
o Alias Sur Une Colonne : Permet de renommer le nom d’une colonne dans les résultats
d’une requête SQL. C’est pratique pour avoir un nom facilement identifiable dans une
application qui doit ensuite exploiter les résultats d’une recherche. Syntaxe :
SELECT Nom_Colonne AS Nouveau_Nom
FROM Nom_Table
WHERE Conditions ;
o Alias Sur Une Table : Permet d’attribuer un autre nom à une table dans une requête SQL.
Cela peut aider à avoir des noms plus court, plus simple et plus facilement compréhensible.
Ceci est particulièrement vrai lorsqu’il y a des jointures à réaliser sur la requête. Syntaxe :
SELECT Nom_Colonne
FROM Nom_Table T Avec T, La Première Lettre du Nom de La Table
WHERE Conditions ;
NB : Le mot clé AS est obligatoire lorsque je dois renommer une colonne. Mais pour renommer la
table, on doit juste spécifier la première lettre du nom de la table et je sépare les deux, par un simple espace.
 La Notion de Jointure En SQL : Manipulation de Plusieurs Tables (02), Pensez A La

Jointure : Les jointures en SQL permettent d’associer plusieurs tables dans une même requête. Cela
permet d’exploiter la puissance des bases de données relationnelles pour obtenir des résultats qui
combinent les données de plusieurs tables de manière efficace. En général, les jointures consistent
à associer des lignes de 2 tables en associant l’égalité des valeurs d’une colonne d’une première
table par rapport à la valeur d’une colonne d’une seconde table.
NB : La Jointure de plusieurs tables se matérialisent toujours et toujours par un lien de jointure. Et

ce lien de jointure est très souvent une clé primaire d’une table A qui a migré vers une table B (et est
devenue clé étrangère ou clé migratoire). Et dans ce cas :
 Lier 2 Tables = 1 Lien de Jointure ;

 Lier 3 Tables = 2 Liens de Jointure ;
 Lier N Tables = (N - 1) Liens de Jointure.
Imaginons une base de données qui possède deux tables :

Table1 (CléPrimaire_Table1, Colonne2_Table1, ColonneN_Table1)
Table2 (CléPrimaire_Table2, Colonne2_Table2, ColonneN_Table2, #CléPrimaire_Table1) ;
NB : la présence de #CléPrimaire_Table1 dans la Table2, voudrais simplement dire que la Table1

a migré dans la Table2 et donc pour les lier, ou les mettre en jointure, on doit écrire :
T1.CléPrimaire_Table1 = T2.CléPrimaire_Table1 (car la clé primaire de la Table1 a migré dans

le table 2 est devenue clé étrangère ou clé migratoire) et dans une requête cela peut donner :
SELECT Colonne2_Table1, ColonneN_Table2 // exemple de colonnes
FROM Table1 T1, Table2 T2 // Je renomme les tables à l’aide des Alias
WHERE T1.CléPrimaire_Table1 = T2.CléPrimaire_Table1 ;
NB : Avec La Jointure, Je Dois Matérialiser Liens de Jointure Dans Le WHERE (Première des
Choses) en plus des Autres Conditions si possible.
2.7. La Notion de Requête Imbriquée En SQL :
Requête A (Requête Externe)
Lier (Relier, Inclure)
Requête B (Requête Interne). // On Exécute B Avant A
Encore appelé Sous – Requête, la Requête Imbriquée en SQL est également aussi appelé requête en
cascade et est une requête SQL qui consiste à exécuter une requête (requête externe) à l’intérieur d’une
autre requête (requête interne). Une requête imbriquée est souvent utilisée au sein d’une clause WHERE
ou de HAVING pour remplacer une ou plusieurs constante.
Une sous - requête est une requête à l'intérieur d'une autre requête. Avec le SQL, vous pouvez
construire des requêtes imbriquées sur autant de niveaux que vous voulez. Vous pouvez également
mélanger jointures et sous - requêtes. Tant que votre requête est correctement structurée, elle peut être aussi
complexe que vous le voulez.
Il y a plusieurs façons d’utiliser les sous-requêtes. De cette façon il y a plusieurs syntaxes

envisageables pour utiliser des requêtes dans des requêtes. Oracle permet d’imbriquer les requêtes, c’est-à-
dire de placer des requêtes dans les requêtes. Une requête imbriquée peut renvoyer trois types de résultats,
Une Valeur Scalaire (Valeur Finie), Une Colonne ou Une Table.
 Requête Imbriquée Qui Retourne Un Seul Résultat : L’exemple de Syntaxe ci-dessous est un
exemple typique d’une sous - requête qui retourne Un Seul Résultat à la requête principale.
SELECT *
FROM Nom_TableA
WHERE Nom_Colonne = (SELECT Valeur
FROM Nom_TableB) ;
Cet exemple montre une requête interne (celle sur “Nom_TableB”) qui renvoi une seule valeur. La
requête externe quant à elle, va chercher les résultats de “Nom_TableA” et filtre les résultats à partir de la
valeur retournée par la requête interne. NB : il est possible d’utiliser n’importe quel opérateur d’égalité tel
que =, >, <, >=, <= ou < >.
 Requête Imbriquée Qui Retourne Une Colonne : Une requête imbriquée peut également
retournée une colonne entière. Dès lors, la requête externe peut utiliser le mot clé IN pour filtrer les
lignes qui possèdent une des valeurs retournées par la requête interne. L’exemple ci-dessous met en
évidence un tel cas de figure :
SELECT *
FROM Nom_TableA
WHERE Nom_Colonne IN (SELECT Nom_Colonne
FROM Nom_TableB
WHERE Conditions) ;
NB : Conditions Avec IN et NOT IN :
 Vous connaissez déjà l'opérateur IN, qui compare une colonne avec une liste de valeurs. En termes
d’appartenance, d’égalité, de contenance ;
 NOT IN : Si l'on utilise NOT IN, c'est bien sûr le contraire donc on exclut les lignes qui
correspondent au résultat de la sous-requête. Et ce cas de figure est fréquent lorsqu’on parlera à
chaque d’une certaine négation dans une requête SQL. Les libellé de ce genre de requête sera du
genre, n’appartient pas, ne figure pas, ne possède pas, n’est pas, ne sont jamais, n’ont jamais. Et
pour ce cas de figure, généralement dans le requête interne B, je fais le contraire du libellé de la
question posé et je relis les deux requêtes par un NOT IN ;
 Les Autres Conditions : Conditions Avec ANY, SOME et ALL :
o Les Conditions avec IN et NOT IN sont un peu limitées, puisqu'elles ne permettent que des
comparaisons de type "Est Egal" ou "Est Différent". Or, Avec ANY et ALL :
 ANY : Veut Dire "Au Moins Une des Valeurs" ;
 SOME : Est Un Synonyme de ANY ;
 ALL : Signifie "Toutes Les Valeurs". La commande ALL permet de comparer une
valeur dans l’ensemble de valeurs d’une sous - requête. En d’autres mots, cette
commande permet de s’assurer qu’une condition est “égale”, “différente”,
“supérieure”, “inférieure”, “supérieure ou égale” ou “inférieure ou égale” pour Tous
Les résultats retourné par une sous-requête.
2.8. Rappel des Commandes En SQL :
3. Cours 3 – Analyse Informatique – La Méthode d’Analyse MERISE

3.1. Généralités Sur La Méthode MERISE :
Le système d'information ou SI, peut être défini comme étant l'ensemble des moyens humains,
matériels et immatériels mis en œuvre afin de gérer l'information au sein d'une unité, une entreprise par
exemple. MERISE : Méthode d’Etude et de Réalisations Informatiques des Sous - Ensembles ou des
Systèmes d’Entreprise est une méthode d’analyse et de conception des systèmes d’information. Elle est née
vers 1978 - 1979, à la suite d’une vaste consultation lancée en 1977 par le ministère de l’industrie pour
choisir plusieurs sociétés de service et de conseil en l’informatique et le CET (Centre d’Etude Technique),
pour mettre au point une méthode de troisième génération de conception et de réalisation de système
d’information. La méthode Merise est basée sur la séparation des données et des traitements à effectuer en
plusieurs modèles conceptuels et physiques. La séparation des données et des traitements assure une
longévité au modèle. Pour cela Merise propose deux approches.
 Approches Par Niveaux :
o Niveau Conceptuel : A ce niveau le système d’information (SI) est représenté

indépendamment de son organisation et les moyens physique et informatique. Les règles
mises en évidence, à ce niveau son des règles de gestion traduisant les objectifs et les
contraintes qui présente l’entreprise. Deux modèles sont proposés à ce niveau : Le modèle
conceptuel des données (MCD) et Le modèle conceptuel des traitements (MCT) ;
o Niveau Logique : A ce niveau sont faite tous les choix techniques afin de déterminer qui
fera quoi, ou, quand et comment. Les traitements sont réalisés dans le système d’information
en tenant compte des contraintes imposées par ces choix. Les deux modèles proposés à ce
niveau sont Le modèle organisationnel des traitements (MOT) et Le modèle logique des
données (MLD) ;
o Niveau Physique : A ce niveau sont fait les choix techniques permettant de déterminer les
moyens informatiques. Les règles misent en évidence sont des règles techniques. Elle
s’exprime en termes de matériels ou de logiciels. Les deux modèles proposés à ce niveau
sont Le modèle physique des données (MPD) et Le modèle opérationnel des traitements
(MOPT).
Dynamique Ou
Niveau Statiques Ou Données Questions ?
Traitements
Conceptuel MCD MCT QUOI ?
Organisationnel Ou
MLD MOT QUI ? QUAND ? Où ?
Logique
Opérationnel Ou Physique MPD MoPT COMMENT ?
 Approches Par Etapes : Merise propose aussi six étapes qui sont :
o Schéma Directeur : l’objectif de cette étape est de faire le point entre la stratégie de
l’entreprise et ses besoins en termes de système d’information ;
o Etude Préalable : cette étape a pour but, de prendre les domaines d’activités domaine par
domaine ; et établir d’une manière plus approfondie les projets à mettre en œuvre et leurs
interfaces ;
o Etude Détaillée : elle a pour but, de décrire d’une manière détaillée les champs d’études ;
et de concevoir un nouveau système en intégrant les nouvelles orientations qui répondent de
la problématique posée, lors de l’étude préalable ;
o Réalisation : elle comprend l’écriture des programmes, l’implémentation des bases de

données où des tests sont faits pour garantir une meilleure intégration de l’ensemble des
transactions ;
o Mise en œuvre : cette étape constitue la mise à la disposition des utilisateurs, le nouveau
système en assurant que toutes les consignes et recommandations seront prises en
considérations ;
o Maintenance : elle consiste à assurer la maintenance de l’application mise en place afin de

la faire durer plus longtemps.
3.2. Les Eléments de La Méthode MERISE :
La Méthode d’Analyse Informatique MERISE est constitué d’un certain nombre d’éléments : Le
Diagramme de Circulation de L’Information - DCI ; Les Règles de Gestion - RG ; Le Dictionnaire de
Données - DDD ; Le Diagramme de Flux - DDF ; Le Graphe des Dépendances Fonctionnelles - GDF ; Le
Modèle Conceptuel de Données - MCD ; Le Modèle Conceptuel de Traitements - MCT ; Le Graphe
d’Ordonnancement des Evènements - GOE ; Le Modèle Organisationnel de Traitement - MOT ; Le Modèle
Externe - ME ; Le Modèle Logique de Données - MLD ; Le Modèle Physique de Données - MPD ;
3.3. Le Modèle Conceptuel de Données :
Le MCD de MERISE est un modèle qui permet de décrire et de modéliser graphiquement les
informations et les objets (appelés entités) manipulés par le système d’information ainsi que les liens entre
les entités. En d’autres termes, le modèle conceptuel des données est une représentation statique (donnée)
d’un système d’information. Autrement dit, c’est une représentation graphique et structurée des
informations mémorisées par un SI. Le MCD est basé sur deux notions principales : les Entités et
les Associations, d'où sa seconde appellation : le Schéma Entité / Association.
3.3.1. Les Règles de Gestion :
Une règle de gestion est un libellé qui décrit le fonctionnement global de l’entreprisse ou de
l’organisation étudiée. Généralement présenter sous forme de phrase simple, Le formalisme de
représentation des règles de gestion est le suivant :
 RG No1 : énoncé de la règle de gestion no1 ;
 RG No2 : énoncé de la règle de gestion no2 ;
 RG Non : énoncé de la règle de gestion non
3.3.2. Le Dictionnaire de Données :
Le dictionnaire des données en abrégé DD, est un tableau qui recense et décrit l’ensemble des
propriétés ou données élémentaires significatives et utiles de l’entreprise ou de l’organisation étudiée. Son
formalisme est le suivant :
Nom Symbolique Signification Type Taille Nature
 Nom Symbolique : il s'agit d'un libellé désignant une donnée tel que présenter dans le MCD
(Libellé Court de La Données) ;
 Signification : il s'agit d'une mention décrivant ce à quoi la donnée correspond (Libellé Long de La
Données) ;
 Type :
o A ou Alphabétique : lorsque la donnée est uniquement composée de caractères

alphabétiques ;
o N ou Numérique : lorsque la donnée est composée uniquement de nombres (entiers ou

réels) ;
o AN ou Alphanumérique : lorsque la donnée peut être composée à la fois de caractères

alphabétiques et numériques ;
o Date : lorsque la donnée est une date (au format AAAA-MM-JJ) ;
o Booléen : Vrai ou Faux ;
 Taille : elle s'exprime en nombre de caractères ou de chiffres ;
 Nature :
o SIG ou Signalétique : ne change presque jamais ;
o SIT ou Situationnel : peut changer en fonction des situations ou évènements ;
o M ou Mouvement : en perpétuel changements ou mouvement ;
NB : Les Données calculées ne figurant pas dans le DDD. Et toutes les données doivent être de type
Elémentaire donc non décomposables.
3.3.3. Présentation des Concepts Liés Au MCD :
 Propriété : C’est le plus petit élément d’information manipulable par le concepteur. Elle est décrite
par un nom, prend des valeurs dans un domaine de valeurs ou types et a une signification dans le
système d’information étudié. Une propriété doit être élémentaire c’est-à-dire ne doit pas être
décomposable en un ensemble de propriétés signifiantes plus petites ;
 Entité : Une entité est la représentation d’un ensemble d’objets de même nature, concrets ou
abstraits, ayant un intérêt pour le système d’information étudié ;
 Association Ou Relation : Une Association Est Un Verbe Toujours à l’infinitif permettant de relier
ou mettre en relation deux entités du système étudié ;
 Cardinalité : Couple de Valeurs appelées cardinalité minimum et cardinalité maximum traduisant

respectivement le nombre de fois minimum et maximum d’une entité peut être en relation avec une
autre entité ;
 Entités Clés Ou Pertinentes : Entités sans lesquels le système ne peut pas être mis en place.
Généralement ces entités ont leur champs ou propriété explicitement et clairement décrits dans le
texte
3.3.4. Etape de Réalisation du MCD :
 Ne Jamais Prendre les Données Calculées dans le MCD ou dans Le Dictionnaire de Données ;
 Ne Jamais Prendre Les Etats comme Entités Sauf Ca Vraiment Exceptionnel. Et dans ce cas l’on
prendra le soin de décrire les champs de ce genre d’entité ;
 Laisser Sans Souligner La Première Propriété dans Le MCD.
Etapes de Mise En Place :
 Lire Et Relire Bien Et Bien Le Texte Pour Comprendre Le Contexte ;
 Identifier Les Entités Pertinentes Avec Leurs Propriétés Respectives ;
 Identifier Les Règles de Gestion Et Les Associations Possibles Entre Entités ;
 Schématiser Le MCD Autrement Faire EPAC = Entités + Propriétés + Associations + Cardinalités ;
3.4. Le Modèle Logique de Données :

3.4.1. Généralités Sur Le MLD :
Le modèle logique de données (MLD) est composé uniquement de ce que l'on appelle des relations.
Ces relations sont à la fois issues des entités du MCD, mais aussi d'associations, dans certains cas. Ces
relations nous permettront par la suite de créer nos tables au niveau physique. Une relation est composée
d'attributs. Ces attributs sont des données élémentaires issues des propriétés des différentes entités, mais
aussi des identifiants et des données portées par certaines associations. Une relation possède un nom qui
correspond en général à celui de l'entité ou de l'association qui lui correspond. Elle possède aussi une clef
primaire qui permet d'identifier sans ambiguïté chaque occurrence de cette relation. La clef primaire peut
être composée d'un ou plusieurs attributs, il s'agit d'une implantation de la notion d'identifiant des entités et
associations qui se répercute au niveau relationnel.
Syntaxe : NomRelation (Attribut1, Attribut12, . . . AttributN)
3.4.2. Règles de Passage du MCD Au Modèle Logique :
 Toute Entité Devient Une Relation ;
 L’Identifiant de L’Entité Devient L’Attribut Principal de La Relation ;
 Les Propriétés de L’Entité Deviennent des Attributs de La Relation ;
 Toute Association de Cardinalité Maximum d’Un Côté Et Minimum de L’Autre Induit Ou Entraine
La Création d’Une Clé Etrangère Noté #CléPère. Une Clé Etrangère Est Ajoutée dans La Relation
Ayant La Cardinalité Minimum ;
 Toute Association de Cardinalité Maximum des Deux Côtés, Devient Une Relation. Et Son Attribut
Principal Est Constitué Par La Concaténation des Clés Qui Ont Migrés
4. Cours 4 - Analyse Informatique – Le Langage de Modélisation UML

4.1. Généralités Sur Le Langage UML :
L’objectif principal de ce cours est de permettre à l’étudiant de découvrir le langage UML (Unified
Modeling Language ou langage de modélisation unifié). UML est un langage de modélisation permettant
la spécification, la construction, la visualisation et la documentation de logiciels. C’est un langage de
modélisation unifié conçu pour fournir une méthode normalisée permettant de visualiser la conception d’un
SI. Il est couramment utilisé en développement de logiciels et surtout en conception orientée objet.
UML 2.3 propose 14 types de diagrammes et comme UML n’est pas une méthode, leur utilisation
est laissée à l’appréciation du concepteur. Il se décompose en plusieurs parties : Les Vue = observables du
système décrivant d’un point de vue les données ; Les Diagrammes = ensemble d’éléments graphiques
décrivant le contenue des vues ; Les Méthodes = éléments graphiques des diagrammes ;
4.2. Les Diagrammes UML :
Les diagrammes UML sont dépendants hiérarchiquement et se complètent, de façon à permettre la

modélisation d'un projet tout au long de son cycle de vie. Il en existe quatorze depuis UML 2.3 :
 Les Diagrammes de Structure ou Diagrammes Statiques :
o Le Diagramme de Classes = Représentation des classes intervenant dans le système ;
o Le Diagramme d'Objets = Représentation des instances de classes (objets) utilisées dans le

système ;
o Le Diagramme de Composants = Représentation des composants du système d'un point de

vue physique, tels qu'ils sont mis en œuvre (fichiers, bibliothèques, bases de données…) ;
o Le Diagramme de Déploiement = Représentation des éléments matériels (ordinateurs,

périphériques, réseaux, systèmes de stockage…) et la manière dont les composants du
système sont répartis sur ces éléments matériels et interagissent entre eux ;
o Le Diagramme des Paquets = Représentation des dépendances entre les paquets (un paquet
étant un conteneur logique permettant de regrouper et d'organiser les éléments dans le
modèle UML), c'est-à-dire entre les ensembles de définitions ;
 Les Diagrammes de Comportement :
o Le Diagramme des Cas d'Utilisation = Représentation des possibilités d'interaction entre le

système et les acteurs (intervenants extérieurs au système), c'est-à-dire de toutes les
fonctionnalités que doit fournir le système ;
o Le Diagramme Etats – Transitions = Représentation sous forme de machine à états finis du

comportement du système ou de ses composants ;
o Le Diagramme d'Activité = Représentation sous forme de flux ou d'enchaînement d'activités

du comportement du système ou de ses composants ;
 Les Diagrammes d'Interaction ou Diagrammes Dynamiques :
o Le Diagramme de Séquence = Représentation de façon séquentielle du déroulement des

traitements et des interactions entre les éléments du système et/ou de ses acteurs ;
o Le Diagramme de Communication = Représentation de façon simplifiée d'un diagramme de

séquence se concentrant sur les échanges de messages entre les objets (depuis UML 2.x).
4.3. Le Diagramme des Cas d’Utilisation :

4.3.1. Présentation Et Définition des Concepts :
Les diagrammes de cas d'utilisation (DCU) sont des diagrammes UML utilisés pour une
représentation du comportement fonctionnel d'un système logiciel. Ils sont utiles pour des présentations
auprès de la direction ou des acteurs d'un projet, mais pour le développement, les cas d'utilisation sont plus
appropriés. En effet, un cas d'utilisation (use cases) représente une unité discrète d'interaction entre un
utilisateur (humain ou machine) et un système. Ainsi, dans un diagramme de cas d'utilisation, les utilisateurs
sont appelés acteurs (actors), et ils apparaissent dans les cas d'utilisation.
4.3.2. La Notion d’Acteur :
Ils sont des entités externes qui interagissent avec le système, comme une personne humaine ou un
robot. Une même personne (ou robot) peut être plusieurs acteurs pour un système, c'est pourquoi les acteurs
doivent surtout être décrits par leur rôle, ce rôle décrit les besoins et les capacités de l'acteur. Un acteur agit
sur le système. L'activité du système a pour objectif de satisfaire les besoins de l'acteur. Les acteurs sont
représentés par un pictogramme humanoïde (stick man) sous-titré par le nom de l'acteur. Dans un DCU, un
acteur est la matérialisation d’un rôle joué dans le SI.
4.3.3. La Notion de Cas d’Utilisation :
Un Cas d’utilisation est une unité cohérente représentant une fonctionnalité visible du système. Il
est sous la forme d’une éclipse. Un acteur peut avoir différents rôles et est amené à intervenir dans une ou
plusieurs situations. Miller (2001) en identifie quatre : Initiateur : acteur qui active le système et déclenche
le cas ; Serveur : acteur aidant le système à assumer ses responsabilités ; Receveur : acteur recevant les
informations du système (système de backup) ; Facilitateur : acteur dont les actions sont effectuées au
bénéfice d'un autre acteur.
4.3.4. Relations Entre Les Cas d’Utilisation :
Trois types de relations sont pris en charge par la norme UML et sont graphiquement représentées
par des types particuliers de ces relations. Les relations indiquent que le cas d'utilisation source présente les
mêmes conditions d'exécution que le cas issu. Une relation simple entre un acteur et une utilisation est un
trait simple :
 Inclusions : Dans ce type d'interaction, la dépendance est obligatoire car le premier cas d'utilisation
inclut le second et son issue dépend obligatoirement de la résolution du second. Elle est représentée
par une flèche en pointillé et matérialisé par le terme « Include ». A Inclut B, Autrement dit A
Dépend de B. Lorsque A Est Sollicité, B L’Est Obligatoirement.
 Extensions : Les Extensions (« Extend ») représentent des prolongements logiques de certaines

tâches sous certaines conditions. Autrement dit un cas d'utilisation A étend un cas d'utilisation B
lorsque le cas d'utilisation A peut être appelé au cours de l'exécution du cas d'utilisation B. c’est une
dépendant optionnelle. Elle est représentée par une flèche en pointillée avec le terme « Extend ».
Ce type de relation peut être utile pour traiter des cas particuliers ou fonctions optionnelles, préciser
les objectifs, ou encore pour tenir compte de nouvelles exigences au cours de la maintenance du
système et de son évolution.
4.3.5. Relation Entre Les Acteurs :
Il est également possible d'appliquer à un acteur la relation de généralisation. Cela se fait notamment
lorsqu'un acteur est un sous-type d'une autre catégorie d'acteurs. Un acteur lié à un autre par ce type de
relation peut interagir avec le système de plus de manières que son parent. La Généralisation : Un Acteur
A est une généralisation de B, si B est un cas particulier de A c'est-à-dire lorsque A peut - être substitué par
B pour un cas précis. Ces relations sont des traits pleins terminés par une flèche en triangle.
4.4. Le Diagramme de Classe :

4.4.1. Définition :
Le diagramme de classes est un schéma utilisé en génie logiciel pour présenter les classes et les
interfaces des systèmes ainsi que leurs relations. Ce diagramme fait partie de la partie statique d'UML, ne
s'intéressant pas aux aspects temporels et dynamiques. Une classe décrit les responsabilités, le
comportement et le type d'un ensemble d'objets. Les éléments de cet ensemble sont les instances de la
classe. Une classe est un ensemble de fonctions et de données (attributs) qui sont liées ensemble par un
champ sémantique. Les classes sont utilisées dans la programmation orientée objet. Elles permettent de
modéliser un programme et ainsi de découper une tâche complexe en plusieurs petits travaux simples.
4.4.2. Schéma de La Classe :
Une classe est représentée par un rectangle séparé en trois parties : la première partie contient le
nom de la classe, la seconde contient les attributs de la classe et la dernière contient les méthodes de la
classe :
 La Première Partie : le nom de la classe. Il est écrit dans le rectangle du haut. Dans une classe
classique, le nom est écrit en romain (exemple : « ClasseClassique »). Le nom d’une classe
commence toujours par une lettre majuscule. Il ne doit pas comporter d'espaces, de signes de
ponctuation ou d'accents. Pour remplacer les espaces, plusieurs conventions existent : on peut
intercaler un symbole _ entre les mots
 La Seconde Partie : les attributs. La syntaxe d'un attribut est la suivante : Visibilité nomAttribut
[multiplicité] : typeAttribut = Initialisation.
La Notion de Visibilité : La notion de visibilité indique qui peut avoir accès à l'attribut. Elle ne
peut prendre que quatre valeurs :
Caractère Rôle Mot clé Description
+ accès public Public Toutes les autres classes ont accès à cet attribut.
accès Seules la classe elle-même et les classes filles (héritage) ont

# Protected
protégé accès à cet attribut.
accès
~ Package Classe visible uniquement dans le package.
package
- accès privé Private Seule la classe elle-même a accès à cet attribut.
NB : Afin de respecter le principe fondamental d'encapsulation, tous les attributs devraient être
privés. Pour qu'un attribut privé ou protégé soit récupérable, on utilise en général un getter (ou accesseur);
pour qu'il soit modifiable, on utilise en général un setter (ou mutateur).
Exemple : + Prenom : String. - Age : int
 La Troisième Partie : les méthodes. La syntaxe d'une méthode est la suivante : Visibilité
nomFonction(nomParamètre : typeParamètreN) : typeRetour
Exemple : + getAge() : int
4.4.3. Relations Entre Les Classe :
Ces relations ne sont pas propres aux diagrammes de classes, elles peuvent également s'appliquer à
l'ensemble des diagrammes statiques.
 Héritage : L'héritage est un principe de division par généralisation et spécialisation, représenté par
un trait reliant les deux classes et dont l'extrémité du côté de la classe mère comporte un triangle.
La classe fille hérite de tous les attributs et méthodes, qu'ils soient publics, protégés ou privés.
Cependant, elle ne peut pas utiliser directement les attributs et méthodes privés (que ce soit en
lecture ou en écriture), sauf par l'intermédiaire d'une méthode héritée (publique ou protégée).
 Association : L'association est une connexion sémantique entre deux classes (relation logique). Une
association peut être nommée. L'invocation d'une méthode est une association. Elle peut être binaire,
dans ce cas elle est représentée par un simple trait, ou n-aire, les classes sont reliées à un losange
par des traits simples. Ces relations peuvent être nommées. L'association n'est utilisée que dans les
diagrammes de classe.
4.4.4. La Notion de Multiplicité :
Comparable aux cardinalités du système Merise, sert à compter le nombre minimum et maximum
d'instances de chaque classe dans la relation liant 2 ou plusieurs classes. La multiplicité représente le
nombre de fois où la variable peut intervenir. Elle est représentée entre crochets : Exactement un : 1 ou
1..1 ; Plusieurs : * ou 0..* ; Au moins un : 1..* ; De un à six : 1..6.
4.4.5. Les Autres Types de Relation Entre Les Classes :

4.4.5.1. L’Agrégation :
L'agrégation est une association avec relation de subordination, représentée par un trait reliant les
deux classes et dont l'origine se distingue de l'autre extrémité (la classe subordonnée) par un losange vide.
Une des classes regroupe d'autres classes. L'objet T utilise une instance de la classe T'. C'est une relation
particulière qui attribue à l'une des classes le rôle d'agrégat et à l'autre classe le rôle d'agrégé. L'agrégation
peut être assimilée à une appartenance - faible -. Soit une configuration constituée d'un certain nombre
d'éléments:
Commentaires:
 L'agrégation se modélise par un losange côté agrégat ;
 Une configuration comporte un clavier - ou aucun -, un écran - ou aucun -, et éventuellement

plusieurs disques ;
 L'agrégation traduit une relation d'appartenance de l'agrégé dans l'agrégat; elle n'induit aucune
valeur de multiplicité particulière.
Commentaires :
 Une page peut contenir des images mais celles-ci peuvent appartenir à d'autres pages ;
 La destruction d'une page n'entraîne pas celle de l'image mais seulement la suppression du lien ;
 Bien sûr nous aurons très souvent une cardinalité 1..1 ou 0..1 côté agrégat ;
 L'appartenance est dite faible car l'agrégé pourra participer à d'autres agrégats et son cycle de vie
n'est pas subordonné à celui de son agrégat. Plus haut la disparition d'une configuration n'entraîne
pas la disparition des périphériques.
4.4.5.2. La Composition :
La composition est une agrégation avec cycle de vie dépendant : la classe composée est détruite
lorsque la classe mère disparait. L'origine de cette association est représentée par un losange plein. L'objet
T' est composé de T. Il s'agit d'une appartenance forte. La vie de l'objet composant est liée à celle de son
composé. La notion de composant est proche de celle d'attribut, si ce n'est que "l'attribut" est "rehaussé" au
rang de classe. On parlera de de réification, on reviendra sur cette notion plus loin.
Commentaires :
 La composition se modélise par un losange noir côté composé ;
 Une application contient de 0 à n fenêtres qui contiennent de 0 à n boutons ;
 La fermeture de l'application entraîne la destruction des fenêtres qui entraîne la destruction des
boutons ;
 la non-présence des valeurs de multiplicités est synonyme de 1..1
NB :
 Un composant ne peut appartenir à un moment donné qu'à un seul composé ;
 La cardinalité ne peut être que de 1 maximum coté composant ;
 La suppression du composé entraîne celle du composant.
4.4.6. Exercice Récapitulatif :
Commentaires :
 Le châssis est un élément indissociable d'une voiture, d'où la composition ;
 Le moteur et les roues peuvent être utilisés dans d'autres voitures ;
 Notez les valeurs 4..4 qui caractérisent plus précisément les valeurs de multiplicité ;
 Les absences de cardinalité sont assimilable à 1..1 ;
 L'association entre Voiture et Personne n'est pas nommée, cela est conseillé lorsque son nom est
trivial: "appartient", "concerne" etc ...afin de ne pas alourdir le modèle, sans rien apporter à la
sémantique.
4.4.7. Etapes de Mise En Place d’Un DDC :
 Lire Et Relire Bien Et Bien Le Texte Pour Comprendre Le Contexte ;
 Identifier Les Entités Pertinentes Avec Leurs Propriétés Respectives ;
 Identifier Les Règles de Gestion Et Les Associations Possibles Entre Entités ;
 Schématiser Le MCD (Entités + Propriétés + Associations + Cardinalités) ;
 Transformer Le MCD Obtenu En Classe :
o Chaque Entité Devient Une Classe (Nom de La Classe, Propriétés, Méthodes) ;
o Inverser Les Cardinalités Afin d’Obtenir Les Multiplicités ;
o Tenir Compte des Spécificités UML (Héritage, Composition ; Agrégation).

CoursRepets CompilCOURS

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CoursRepets CompilCOURS

Transféré par

Droits d'auteur :

Formats disponibles

Mon BORD « MonBTS » - Recueil de Cours Pour La Préparation Au BTS Filières IGL & GSI

Ministère de L’Enseignement Supérieur

Préparation Examen du BTS - Filières Informatiques (IGL / GSI)

Recueils de Cours Expliqués

1) Algorithmes Et Structures de Données Avancées ;

2) Base de Données Et Le Langage SQL ;

3) Analyse Informatique – MERISE ;

4) Analyse Informatique – Langage UML.

1. Cours 1 - Algorithmes Et Structures de Données Avancées .............................................................6

1.1. Généralités .....................................................................................................................................6

1.1.1. Structure Générale d’Un Algorithme : ....................................................................................6

1.1.2. La Notion de Types de Données ..............................................................................................6

1.1.3. La Notion de Variable .............................................................................................................7

1.1.4. La Notion de Constante ...........................................................................................................7

1.1.5. Les Opérateurs de Base ...........................................................................................................7

1.1.6. La Notion d’Affectation En Algorithme..................................................................................7

1.2. Les Instructions de Lecture Et d’Ecriture En Algorithme .......................................................8

1.2.1. Les Instructions de Lecture ......................................................................................................8

1.2.2. Les Instructions d’Ecriture ......................................................................................................8

1.3. Etapes de Résolution des Algorithmes ........................................................................................8

1.4. Les Structures Conditionnelles ....................................................................................................9

1.4.1. Structures Conditionnelles A Un Choix ..................................................................................9

1.4.2. Structures Conditionnelles A Deux Choix ..............................................................................9

1.5. La Notion des Boucles An Algorithme ......................................................................................10

1.5.1. La Boucle Pour . . . FinPour ..................................................................................................10

1.5.2. La Boucle TantQue . . .FinTantQue ......................................................................................11

1.5.3. La Boucle Répéter . . . Jusqu’à ..............................................................................................12

1.6. Les Enregistrements En Algorithme .........................................................................................13

1.6.1. Généralités Et Définition .......................................................................................................13

1.6.2. Exemple Et Explication .........................................................................................................13

1.6.3. Lecture Variable Type Enregistrement ..................................................................................14

1.6.4. Ecriture Variable Type Enregistrement .................................................................................14

1.7. Les Tableaux En Algorithme .....................................................................................................14

1.7.1. Définition des Variables Type Tableau .................................................................................14

1.7.2. Exemple Et Explication .........................................................................................................15

1.7.3. Manipulations de Base Sur Le Type Tableau ........................................................................15

1.7.4. Algorithmes Type Tableau ....................................................................................................16

1.8. Les Tableaux d’Enregistrement Ou Vecteurs En Algorithme ................................................19

1.8.1. Généralités .............................................................................................................................19

1.8.2. Exemple Et Explication .........................................................................................................19

1.9. Les Procédures Et Fonctions ......................................................................................................20

1.9.1. Généralités .............................................................................................................................20

1.9.2. Structure Générale de La Procédure ......................................................................................21

1.9.3. Structure Générale de La Fonction ........................................................................................21

1.9.4. Exemple d’Exercice Sur Les Procédures Et Fonctions .........................................................21

1.10. Les Principes En Algorithme .....................................................................................................23

1.10.1. Principe 1 – La Manipulation de La Variable Type Date ......................................................23

1.10.2. Principe 2 – Définition de La Structure de Données Dans Un Enoncé .................................24

1.10.3. Principe 3 – Enregistrer Les Eléments Dans Un Vecteur d’Enregistrement .........................24

1.10.4. Principe 4 - Parcourir Les Eléments d’Un Vecteur d’Enregistrement ..................................27

1.10.5. Principe 5 : Trier Les Eléments dans Un Vecteur .................................................................29

1.10.6. Identifier Les Paramètres Pour Un Sous – Programme .........................................................30

1.11. Les Structures de Données Avancées ........................................................................................31

1.11.1. Les Fichiers ............................................................................................................................31

1.11.2. Les Listes Chainées ...............................................................................................................32

2. Cours 2 – Base de Données Et Langage SQL Et Algèbre Relationnel ..........................................33

2.1. Généralités Sur Les Base de Données .......................................................................................33

2.2. Le Langage SQL..........................................................................................................................33

2.3. Les Commandes SQL .................................................................................................................33

2.4. Les Fonctions d’Agrégation En SQL ........................................................................................40

2.5. Autres Commandes En SQL ......................................................................................................41

2.6. La Notion de Jointure En SQL ..................................................................................................43

2.7. La Notion de Requête Imbriquée En SQL ...............................................................................44