Résumé : Pointer@Info

Merise - SQL - SQL Procedural (MySQL) - TSQL (SQL Server) - PLSQL (Oracle) - NOSQL
(MongoDB)

Table des matières

1. Définition d’un Système : ................................................................................................................ 2
2. La représentation schématique d’un système : .............................................................................. 2
3. Définition d’un Système d’information (SI) : ................................................................................... 2
4. Les informations et traitements ...................................................................................................... 3
5. Merise et les approches par niveaux :............................................................................................. 3
6. Cahier de charge : ............................................................................................................................ 4
7. Dictionnaire des données : .............................................................................................................. 4
8. Les dépendances fonctionnelles (DF) : ............................................................................................ 5
9. Graphe de dépendance fonctionnelle (GDF) :................................................................................. 6
10. Modèle E/A : Modèle Conceptuel de données (MCD) .................................................................... 6
11. La normalisation : ............................................................................................................................ 9
12. Le modèle logique de données (MLD) :......................................................................................... 10
13. Les règles d’intégrité structurelle : ................................................................................................ 12
14. Le modèle physique des données (MPD) : .................................................................................... 12
15. Base des données, SGBD et SGBDR ............................................................................................... 13
16. Algèbre Relationnel : ..................................................................................................................... 14
17. SQL : ............................................................................................................................................... 15
18. SQL procédurale MySQL: ............................................................................................................... 27
19. T-SQL (Transact-SQL) de Microsoft SQL Server : .......................................................................... 34
20. PLSQL ............................................................................................................................................. 38
21. NoSQL avec MongoDB:.................................................................................................................. 41

1
 1. Définition d’un Système :
Un Système : Désigne un ensemble de parties similaires qui participent à une activité commune. C’est
un dispositif formé par la réunion d’éléments analogues.

Combinaison de parties qui se coordonnent pour donner un résultat, de manière à former un ensemble

Tous Système fonctionne en transformant des flux d’entrée en flux de sortie selon des processus plus
ou moins complexe.

2. La représentation schématique d’un système :

a. Système de pilotage :
Définit les missions, les objectifs, organise l’emploi les moyens, contrôle l’exécution des travaux,
Contrôle le système opérant.

Il est relié aux autres systèmes par des flux d’informations internes.

b. Système information :
C’est l’ensemble des ressources humaines, techniques et financières qui fournissent, utilisent,
compilent, traitent et distribuent l’information de l’organisation

Il alimente l’organisation en informations d’origines diverses (internes ou externes).

Il est la passerelle obligatoire pour toutes les informations de l’entreprise.

c. Système opérant
C’est l’ensemble des moyens humains, matériels, organisationnels qui exécutent les ordres du système
de pilotage.

Il assure le fonctionnement du système global, son activité est contrôlée par le système de pilotage.

3. Définition d’un Système d’information (SI) :

C’est une présentation Opérationnelle de la réalité = Partie Statique + Partie Dynamique

2
 - Partie Statique: Informations associées aux activités de l’organisation
- Partie Dynamique: manipulation des données, aide à la décision

Un Système d’information est un ensemble de taches complexes regroupées en modules spécialisés

qui composent l’applicatif informatique : le logiciel (application informatique).

Le logiciel a besoin d’un plan de conception, C’est pourquoi un logiciel doit avoir une étude préalable,
une méthodologie.
La méthode existant dite : Merise (Méthode d’Etude et de Réalisation Informatique par les Sous-
Ensembles ou pour les Système d’Entreprise).

4. Les informations et traitements

SI = Informations (partie Statique) + Traitements (partie dynamique)

a. Les informations :
L’information est l’émission ou la réception de signaux qui provoque l’échange et l’animation dans une
organisation.

Les informations se recueillent à l’intérieur du système d’information étudié. La liste d’informations

est constituée de plusieurs façons :
• L’interview.
• L’étude des documents internes.
• L’étude des documents externes.
Existe deux types d’informations élémentaires (mémorisable) et calculées.

- Les informations élémentaires : sont des informations dont les valeurs ne peuvent pas
être inventées, elles ne sont pas déductibles d’autres informations, dite atomique non
divisible.
- Les information Calculées : Les informations calculées sont déductibles des informations
élémentaires.

b. Les traitements :
Les opérations peuvent être de deux sortes automatiques ou manuels. Ils sont déclenchés par l’arrivée
d’évènements.

5. Merise et les approches par niveaux :

Merise est un acronyme signifiant Méthode d’Étude et de Réalisation Informatique par les Sous-
Ensembles ou pour les Systèmes d’Entreprise.

La méthode Merise a comme objectif d’aider, de guider les Ssii (Société de service et d'ingénierie
informatique), dans leurs phases d’analyses, de conception et le développement de l’applicatif.

Les niveaux d’approches dans merise sont la suivante :

3
 6. Cahier de charge :
Décrit les éléments du projet par une analyse complète des Besoins Fonctionnelles, Opérationnels,
Non Fonctionnelles et Les Contraintes. Il s’agit d’une référence ou bien un document contractuel sur
lequel les développeurs se basent pour concevoir et implémenter une base de données.

Existent deux types de cahier des charges :

o Technique (CDCT) : Il contient les exigences et contraintes techniques, économiques,

industrielles, environnementales et matérielles d’un projet. Il sert à définir Architecture technique,
les outils à utiliser, les technologies…

o Fonctionnel(CDCF) : décrit la structure, les besoins et fonctionnalités attendues du maître

d’ouvrage. Il contient les informations qui permettent d’adresser les exigences liées au projet en
précisant les conditions de réalisation. Le CDCF doit comporter assez de détails pour être
compréhensible par tous les acteurs du projet.

7. Dictionnaire des données :

Pour que le cahier de charge soit traitées de manière informatisée, les données doivent être décrites
dans un formalisme compris par le système informatique qui va les gérer. C’est pourquoi en utilise le
dictionnaire des données.

 Nom de la donnée : Cette cellule recevra une donnée par exemple : Nom client.
 Format : Ici sera indiqué le format de la donnée, par exemple : alphabétique, alphanumérique,
numérique, date, logique.
 Longueur : La longueur approximative ou exacte de la donnée sera indiquée, par exemple : 30.
 Type : Une croix sera inscrite dans la colonne pour indiquer si la donnée est élémentaire ou
calculée.
 Règle de calcule : Ici sera indiquée de manière claire la formule ou le calcul nécessaire à appliquer
pour obtenir la donnée.

4
 Règle de gestion : Dans cette zone sera indiquée, si nécessaire, la règle de gestion inhérente à la
donnée.
 Document : La rubrique document permet de saisir le document dans lequel a été trouvée la
donnée

8. Les dépendances fonctionnelles (DF) :

C’est l’étape qui suive le dictionnaire des données, c’est réaliser les liaisons entre les données
existant dans le dictionnaire. Les dépendances fonctionnelles sont la pierre angulaire de toute
l’analyse des données.

a. Définition :

Un attribut B dépend fonctionnellement de l’attribut A, noté AB si à une valeur de A correspond

une et une seule valeur pour B . On dit que A déterminé B.

Par exemple :
La connaissance de la valeur d’un numéro de client nous permet de connaître sans ambiguïté la valeur
d’un et d’un seul nom de client. Dans la fiche d’adhérent, l’adhérent numéro 1 a pour nom Hassan.
Numéro client →Nom client,
Numéro client → prénom,
Numéro client → adresse, Numéro client → (Nom client, prénom, adresse, code
Numéro client → code postal, postal, ville, téléphone, mail)
Numéro client → ville,
Numéro client → téléphone,
Numéro client → mail Source But
b. Dépendances fonctionnelle composées :
Une dépendance fonctionnelle qui comporte plusieurs attributs est dite composée.

Un exemple: (Numéro Coureur, Numéro course) → (temps)

Connaissant le numéro du coureur et le numéro de la course, nous connaissons de façon certaine le

temps chronométré d’un coureur précis sur une course précise.

c. Dépendances fonctionnelle élémentaire :

Une dépendance fonctionnelle A → B est élémentaire s’il n’existe pas une donnée C, sous ensemble
de A, décrivant une dépendance fonctionnelle de type C → B.

Une DF (a,b)  c est élémentaire si ni ac, ni bc ne sont des DF

RéférenceProduit → Désignation // c’est une DF

NuméroCommande, RéférenceProduit → Quantité // c’est une DF
NuméroCommande, RéférenceProduit → Désignation // c pas une DF car pour connaitre la
Désignation il suffit de connaitre la référence
d. Dépendance fonctionnelle élémentaire direct
On dit que la dépendance fonctionnelle A → B est directe s’il n’existe aucun attribut C tel que l’on
puisse avoir A → C et C → B. En d’autres termes, cela signifie que la dépendance fonctionnelle entre A
et B ne peut pas être obtenue par transitivité.

5
Exemple :

NumClasse → NumElève
NumEleve → NomElève
NumClasse → NomElève
La troisième dépendance fonctionnelle n’est pas directe car nous pourrions écrire :
NumClasse → NumElève → NomElève

9. Graphe de dépendance fonctionnelle (GDF) :

Le graphe des dépendances fonctionnelles est une représentation graphique qui illustre les relations
de dépendance fonctionnelle entre les différentes données.
Exemple :

 NumFou : Doit être souligne car il détermine d’autre éléments.

 numFou et codeArt sont des détermine de prixAchat
 desArt est déterminé par codeArt

10. Modèle E/A : Modèle Conceptuel de données (MCD)

Ecrire de façon formelle les données d’une base de données. Il s’agit donc d’une représentation des
données. Facilement compréhensible, permettant de décrire la base de données à l’aide d’entités. Il
est à la base de tous SGBD dits relationnels qui sont les plus utilisés actuellement dans les entreprises.

Il est généralement représenté à l’aide du formalisme « entités-association » sous la forme de :

ENTITES, ASSOCIATIONS et ATTRIBUTS

a. Entité :
Concept concret ou abstract identifié du monde réel caractérisé par un nom et une liste de propriétés.
L’entité se représente par un cadre contenant le nom de l’entité.

b. Les attributs :
Propriété d’une entité ou d’une association caractérisée par un nom et un type élémentaire.
C’est un élément d’une entité :
- A un nom unique.
- Permet de mémoriser une valeur ou bien une donnée élémentaire.
- Doit avoir un sens (donc une valeur) pour chacune des occurrences de la composante.

6
Une entité il peut avoir au moins un identifiant. Cet identifiant est unique permet d’identifier chaque
occurrence de l’entité.

En peut créer plusieurs Occurrences à partir d’une entité, une occurrence est un objet ou bien une
instance d’une entité. Deux occurrences de l’entité ne peuvent avoir la même valeur d’identifiant

c. Association :
Lien logique entre entités dont le type est défini par un verbe et une liste éventuelle de propriétés.
On appelle collection de l’association l’ensemble des entités qu’elle relie.

Un attribut peut être placé dans une association uniquement lorsqu’il dépend de toutes les entités
liées par l’association.

La concaténation des identifiant des entités liés à une association constitue l’identifiant de cette
association (cet identifiant n’est pas mentionné sur le modèle).

L’identifiant de l’association effectuer est le couple (N° client, N° commande)

d. Les cardinalités :
Contrainte inscrite à chaque extrémité d’une association comportant un couple de valeurs (min - max)
qui établit, pour chaque entité de l’association, le nombre minimum et maximum d’occurrences d’une
association auxquelles elle peut participer.

Exemple : Un client peut effectuer de 0 à n commande, mais une commande ne peut être effectuer
que par un seul client.

7
Les seules cardinalités admises sont:

Cardinalités Signification

0…1 Au plus un

1…1 (ou 1) Un seul

0…n (ou *) Un nombre indéterminé

1…n Au moins un

e. Les types d’association :

Les associations plurielles : Deux mêmes entités peuvent être plusieurs fois en association.

Les associations réflexives : Une association réflexive est une association reliant des occurrences de
la même entité

Les associations ternaires: Une association ternaire est une association qui décrit un lien sémantique
entre trois entités.

8
11. La normalisation :
a. Première forme normale (1FN ou 1NF) :
- Attribut élémentaire.
- Tous les attributs ne contiennent qu’une seule valeur atomique (non divisible).
- Les attributs ne contiennent pas de valeurs répétitives.
- Tous les attributs en dépendance fonctionnelle avec l’identifiant de cette relation.

Exemple :
Clients (NumCli, Nom, Prénom, Adresse, Téléphone)
Cette relation n’est pas en première forme normale, car Adresse n’est pas atomique.

b. Deuxième forme normale (2FN ou 2NF) :

- Être en 1FN.
- Les attributs non clé dépendent de la totalité de la clé, et non d'une partie de la clé.
- Dépendance fonctionnelle élémentaire

Exemple :
Commande (Numcli, CodeArticle, Date, Qté commandée, Désignation)
Cette relation est-elle en première forme normale ? Oui.
Est-elle en deuxième forme normale ? Non, car la propriété Désignation ne dépend pas
Intégralement de la clé (Numcli, CodeArticle, Date).

c. Troisième forme normale (3FN ou 3NF) :

- Être en 2FN.
- Chacun des attributs de la relation ne dépend que de la clé et non pas d'un autre attribut de
la relation.
- Dépendance fonctionnelle élémentaire directe, pas de transition

Exemple :
La relation Commande(NuméroCommande, #CodeClient, Nom client, #RefArticle)
est elle en troisième forme normale ?
Est elle en première forme normale ? Oui
Est elle en deuxième forme normale ? Oui
Est elle en troisième forme normale ? Non !
En effet Nom client dépend d’une propriété non clé : CodeClient

d. Forme normale de Boyce-Codd (FNBC ou BCNF)

- Être en 3FN.
- Les seules dépendances fonctionnelles élémentaires existantes dans les relations sont celles
de la clé vers les attributs non clés.

Exemple :
La relation Commune(commune, ville, région, population) n'est pas en forme normale de
Boyce-Codd (FNBC ou BCNF)
- (commune, ville) → région et (commune, ville) → population : Cela signifie que la
combinaison d'une commune et d'une ville détermine la région ainsi que la population.
- ville → région : Cela signifie que la ville détermine également la région. Ici, cette dépendance
crée une violation de la BCNF, car ville n'est pas une superclé (la superclé est (commune,
ville)).

9
 - Solution est la Décomposition : Commune (commune, ville, population) et Ville (ville,
région) :

e. Quatrième forme normale(4FN–NF4)

- Elle est déjà en forme normale de Boyce-Codd (BCNF) et qu'elle ne contient pas de
dépendances multivaluées non triviales.

12. Le modèle logique de données (MLD) :

Le modèle logique des données (MLD) est une étape intermédiaire pour passer du modèle E/A, qui est
un modèle sémantique, vers une représentation physique des données : Fichier, SGBD hiérarchique,
SGBD réseau, SGBD relationnel.

Dite aussi Schéma relationnel:

 Les tables sont appelées relations

 Les liens entre clefs étrangères et leur clefs primaires sont symbolisés par un connecteur

a. Tables, lignes, colonnes, attribut et domaine :

Lorsque les données ont la même structure (par ex. renseignement relatifs à un client), on peut alors
les organiser en tables dans lesquelles:

• Les colonnes décrivent les champs en commun

• Les lignes contiennent les valeurs de ces champs pour chaque enregistrement.

Une table est une relation comportant des ligne (tuples) et des colonnes.

Attribut : Colonne d’une relation caractérisée par un nom

 Domaine: Ensemble des valeurs admises pour un attribut, il établit les valeurs acceptables
dans une colonne peut être des (entier, booléen, caractère, réel)

b. Clefs primaire et clefs étrangères :

Les clefs primaires (primary key) permet de rendre Les lignes d’une table unique  il existe au moins
une colonne qui sert à identifier les lignes il s’agit de la clef primaire de la table.

Clé primaire : Ensemble minimal de colonne qui permet d’identifier de manière unique tuple dans une
table, peut être Pk simple ou bien composé.

Les propriétés et conventions requises :

• La valeur vide Null est interdite
• La valeur de la clef primaire d’une ligne ne devrait pas changer au cours du temps
• On souligne les clefs primaires

Clé étrangère: Une ou plusieurs colonnes dans une table qui a pour but d’assurer une liaison entre
deux tables la clef primaire de la première table est dupliquer dans la deuxième on l’appelle aussi clef
externe (Foreign key), il fait précéder par # la clef étrangère

10
 c. Conversion de MCD vers MLD :
Comparaison des notions entre MCD et MLD dite aussi modelé relationnel:

Toute entité dans un MCD devient une table dans un MRD dans laquelle les attributs deviennent les
colonnes et l’identifiant de l’entité constitue la clef primaire de la table.

 Association binaire 1/1 – 0/1

 Association binaire plusieurs à plusieurs

 Association binaire un à plusieurs

 Association n-aire (n>2)

11
 Association réflexive:

13. Les règles d’intégrité structurelle :

Les règles d’intégrité sont les règles que doivent vérifier les données contenues dans une base de
données. Ces règles sont inhérentes au modèle de données

On distingue plusieurs règles structurelles correspondant au concepts :

 Entité
 Domaine
 Clef (contrainte référentielle)

Contrainte d’entité : Contrainte imposant que toute relation possède une clef primaire et tout attribut
participent à cette clef primaire est non nul.

Contrainte de domaine : Contrainte imposant que la colonne d’une relation doit comporter des valeurs
vérifiant une assertion logique. Par exemple l’âge d‘une personne est compris entre 1 et 150.

Contrainte référentielle (clef étrangère): Contrainte d’intégrité portant sur une relation R1, consistent
à imposer que la valeur connue d’un groupe d’attributs (appelé clef étrangère) apparaisse comme
valeur de clef dans une autre relation R2.

 Lors d’une insertion d’une valeur dans une relation, la valeur des attributs doit exister dans la
relation référencée.
 Lors d’une suppression dans la relation référencée, les tuples référençant ne doivent pas
exister

14. Le modèle physique des données (MPD) :

Transformer les tables relationnelles sous forme des lignes, en commence par les tables sans clé
étrangère suivie par celle avec les clés étrangères.

12
 Matiére(No_matiere)
Professeur(No_prof)
Classe(No_class)
Assure(#No_class, #No_Prof,#No_matiere, codsalle)

15. Base des données, SGBD et SGBDR

Une Base de données :
Def1 : C’est un ensemble de données modélisant les objets d’une partie du monde réel et servant de
support à une application informatique.

Def2 : C’est un ensemble structuré de données enregistrées sur des supports accessibles par
l’ordinateur pour plusieurs utilisateurs.

DB permet:
- L’Organisation et la description de données.
- Le Stockage sur disque.
- Le Partage des données.
- La Confidentialité.
- La Performance.
Un SGBD (Système de
Un Système de Gestion de bases de Données (SGBD) :
Gestion de Bases de Données) est un ensemble logiciel qui permet la structuration, le stockage, et la
manipulation d'une base de données.

Les types de SGBD : SGBD hiérarchique – SGBD relationnel – SGBD objet

Un Système de Gestion de bases de Données Relationnel (SGBDR) :

Dans notre cas en va s’intéresser à un SGBDR qui dominent le marché des SGBD. Ce type de
systèmes est fondée sur la théorie mathématique des relations. Il s’agit de représentation
simple des données sous forme de tables constituées de lignes et de colonnes.

13
 16. Algèbre Relationnel :
Union A={1,2,3} B={3,4,5} A∪B={1,2,3,4,5}

Différences A={1,2,3,4} B={3,4,5,6} A-B={1,2} B-A={5,6}

Produit cartésien A={1,2} B={x,y,z} A×B={(1,x),(1,y),(1,z),(2,x),(2,y),(2,z)}

Projection (ID: 1, Nom: Alice, Âge: 20, Ville: Paris)

(ID: 2, Nom: Bob, Âge: 22, Ville: Lyon)

π (Nom, Ville)
(Nom: Alice, Ville: Paris)
(Nom: Bob, Ville: Lyon)

Restriction (ID: 1, Nom: Alice, Âge: 20, Ville: Paris)

(ID: 2, Nom: Bob, Âge: 22, Ville: Lyon)

σ(Age>=22)
(ID: 2, Nom: Bob, Âge: 22, Ville: Lyon)

Inéqui-jointure "Employés" :
(Num: 1, Nom: Alice, Projet: 101)
(Num: 2, Nom: Bob, Projet: 102)
(Num: 3, Nom: Claire, Projet: 101)
"Projets" :
(NC: 101, Nom_Projet: Projet A)
(NC: 102, Nom_Projet: Projet B)

Num != NC
(Num: 1, Nom: Alice, Projet: 102)
(Num: 2, Nom: Bob, Projet: 101)
(Num: 3, Nom: Claire, Projet: 102)

Jointure naturelle Num = NC

(Num: 1, Nom: Alice, Projet: 101, Nom_Projet: Projet A)
(Num: 2, Nom: Bob, Projet: 102, Nom_Projet: Projet B)
(Num: 3, Nom: Claire, Projet: 101, Nom_Projet: Projet A)

Jointure externe "Clients" :

(ID_Client: 1, Nom: Alice)
(ID_Client: 2, Nom: Bob)
"Commandes" :
(ID_Commande: 101, ID_Client: 1)
(ID_Commande: 102, ID_Client: 3)

Jointure Externe Complète

(ID_Client: 1, Nom: Alice, ID_Commande: 101)
(ID_Client: 2, Nom: Bob, ID_Commande: null)
(ID_Client: null, Nom: null, ID_Commande: 102)

semi-jointure "Clients" :

14
 (ID_Client: 1, Nom: Alice)
(ID_Client: 2, Nom: Bob)

"Commandes" :
(ID_Commande: 101, ID_Client: 1)
(ID_Commande: 102, ID_Client: 3)

Résultat final de la semi-jointure :

(ID_Client: 1, Nom: Alice)

intersection Ensemble A
(Num: 1, Nom: Alice)
(Num: 2, Nom: Bob)
(Num: 3, Nom: Claire)

Ensemble B
(Num: 2, Nom: Bob)
(Num: 4, Nom: David)
(Num: 5, Nom: Eva)

A⋂B
(Num: 2, Nom: Bob)

Division M={Math,Science}
I={(Alice,Math),(Alice,Science),(Bob,Math),(Charlie,Math),(Charlie,Science)}
Résultat=I÷M
Résultat={(Alice),(Charlie)}

Complément Couleur = (Jaune, rose, Blanc)

Region = (Paris, Marseille, Lyon)

Fermeture transitive R={(A,B),(B,C)}

R+={(A,B),(B,C),(A,C)}

17. SQL :
a. LDD (MySQL)
Vérifier les valeurs des ports :
Direction du client au serveur MySQL
SHOW VARIABLES LIKE 'port';
Direction du serveur au client MySQL
show VARIABLES like 'mysqlx_port'; Valeur retourne : 33060

Créer une base de donné : create DATABASE test ;

15
CREATE DATABASE [if not exists ] show create DATABASE test;
MaBase
[CHARACTER SET utf8mb4]
[COLLATE utf8mb4_general_ci];
Utilisation d’une base de donné :
use test;
Supprimer une DataBase:
DROP DATABASE test
Afficher les moteurs de stockage :
show ENGINES;

Création d’une table : CREATE TABLE IF NOT EXISTS

CREATE TABLE [IF NOT Utilisateurs (
EXISTS] nom_table ( id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50) NOT NULL,
nomCol1 typeCol
prenom VARCHAR(50) NOT NULL,
[contraintes], nomCol2 email VARCHAR(100) NOT NULL UNIQUE
typeCol [contraintes], ... )
nomColN typeCol ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLAT
[contraintes] E=utf8mb4_general_ci;
)[ENGINE=type_moteur]
[DEFAULT
CHARSET=jeu_de_caractères]
[COLLATE=nom_collation];

Afficher la structure de la table DESCRIBE nom_table;

Verrouiller les tables LOCK TABLES nom_table [READ| WRITE]

déverrouiller les tables UNLOCK TABLES;

Création des Vues : CREATE VIEW nom_de_vue AS

Une vue est une table virtuelle basée SELECT colonne1, colonne2, ...
sur le résultat d'une requête SQL. FROM table
WHERE condition;

Supprimer d’une vue DROP VIEW nom_de_vue;

Création de table temporaire : CREATE TEMPORARY TABLE nom_table_temporaire (

Une table temporaire est une table colonne1 type_donnée,
qui n'existe que pendant la durée de colonne2 type_donnée,
la session ou de la transaction. ...
);
Pour la Supprission DROP TABLE nom_table_temporaire;

16
 Type de données (colonne)
Numériques : TINYINT, SMALLINT, MEDIUMINT, INT ou INTEGER, BIGINT, FLOAT, DOUBLE,
DECIMAL

Caractères : CHAR, VARCHAR, TINYBLOB, TINYTEXT, BLOB, TEXTE, MEDIUMBLOB,

MEDIUMTEXT, LONGBLOB, LONGTEXT

date/heure : DATE, TIME, ANNÉE, DATETIME, TIMESTAMP

Les Contraintes
NOT NULL : Obligation de donner nom_colonne type_donnee NOT NULL;
une valeur
UNIQUE : Interdit deux même nom_colonne type_donnee UNIQUE;
valeurs pour une même colonne )
Ou bien:
nomCol1 type_donnee,
nomCol2 type_donnee,
UNIQUE(nomCol1 , nomCol2 );

Ou bien :
[CONSTRAINT nomContra] UNIQUE(nomCol1 , nomCol2 );

PRIMARY KEY : Clé primaire nomCol Type_donnee PRIMARY KEY,

Ou bien dans le cas de plusieur pk :
nomCol1 Type_donnee PRIMARY KEY,
nomCol2 Type_donnee PRIMARY KEY,
Ou bien:
nomCol1 Type_donnee PRIMARY KEY,
nomCol2 Type_donnee PRIMARY KEY,
PRIMARY KEY(nomCol1, nomCol2)

REFERENCES <table>(col) : CONSTRAINT nom_contrainte FOREIGN KEY

Clé étrangère, établit une relation avec (nom_colonne) REFERENCES
une autre table via sa clé primaire table_parent(nom_colonne_p)
[ON DELETEreference_option]
[ON UPDATEreference_option]

Example:
CONSTRAINT fk1_cin FOREIGN KEY (numCIN)
REFERENCES users(numCIN)

CHECK(condition) : Emet une [CONSTRAINT [nom_contrainte]]

condition sur une colonne CHECK(expression) [[NOT] ENFORCED]

Example :
Cout DECIMAL(10,2 ) NOT NULL CHECK (cout>= 0),

DEFAULT : Définit une valeur par nom_colonne type_donnee DEFAULT valeur_par_defaut;

défaut
Supprimer et modifier la table

17
Ajouter une ou plusieurs colonnes à ALTER TABLE nom_table
une table: ADD nouvelleCol1 [definition1],
ADD nouvelleCol2 [definition2],

Exemple1 une seule colonne :

ALTER TABLE users

ADD telephone VARCHAR(10);
Exemple1 plusieurs colonnes :
ALTER TABLE users (
ADD telephone VARCHAR(10,
Age integer NOT NULL CHECK (age>= 18)
);

Modifier une ou plusieurs colonnes à ALTER TABLE nom_table

une table: MODIFY nouvelleCol1 [definition1],
MODIFY nouvelleCol2 [definition2],
...;

Exemple1 une seule colonne :

ALTER TABLE users
MODIFY prenom VARCHAR(40) ;

Exemple1 plusieurs colonnes :

ALTER TABLE users (
MODIFY prenom VARCHAR(40),
Age integer CHECK (age>= 28)
);

changer le nom d’une colonnes d’une ALTER TABLE nom_table CHANGE COLUMN
table: nom_original nouveau_nom[definition];

Exemple:
ALTER TABLE users
CHANGE COLUMN prenom last_name
VARCHAR(40);

Supprimer une colonne d’une table : ALTER TABLE nom_table DROP COLUMN
nom_colonne;

Exemple:
ALTER TABLE users DROP COLUMN age;

Renommer le nom d’une table : ALTER TABLE nom_table RENAME TO

nouveau_nom_table;
Exemple:
ALTER TABLE users RENAME TO personnes;

Ajouter ou supprimer une clé primaire ALTER TABLE nom_table

ADD PRIMARY KEY(column_list);

ALTER TABLE nom_table

DROP PRIMARY KEY;

Ajouter et supprimer une clé étrangère ALTER TABLE nom_table

18
 ADD CONSTRAINT constraint_name
FOREIGN KEY (column_name, ...)
REFERENCES parent_table(colname,..);

ALTER TABLE nom_table

DROP FOREIGN KEY nom_contrainte;

Ajouter et supprimer une contrainte ALTER TABLE nom_table

ADD CONSTRAINT nom_contrainte
UNIQUE (liste_colonnes);

ALTER TABLE nom_table

DROP INDEX nom_contrainte;

Supprimer une table ou plusieurs DROP [TEMPORARY] TABLE [IF EXISTS] nom_table1,
nom_table2,…

b. LMD (MySQL)
Insertion d’une ou plusieurs lignes : INSERT INTO
nom_table(col1,col2,...)
VALUES(val1,val2,...);

Ou bien plusieurs lignes:

INSERT INTO nom_table (c1,c2,...)
VALUES(v01,v02,...),
(v11,v22,...),
..
(vn1,vn2,...);

Le cas d’insertion de tous les

cols :
INSERT INTO nom_table
VALUES(v1,v2,...);

Example:
INSERT INTO users(num,nom,prenom)
VALUES(120,’maryem’,’saidi’);

Modification les valeurs d’une ligne UPDATE nom_table SET nom_col1 =

expr1,
nom_col2 = expr2,...[WHERE
condition];

Example:
UPDATE users SET age=31,
nom=’laila’ WHERE Num=12;

Supprimer une ligne DELETE FROM nom_table WHERE

Conditions

Example:
DELETE FROM users WHERE Num=12;
La sélection des données : SELECT [DISTINCT] Liste_Select | * FROM
Liste_Tables

19
 INNER JOIN Table AS T1 ON T1.ID = T2.ID
WHERE Liste_Conditions_Recherche
GROUP BY Liste_regroupement
HAVING Liste_Conditions_regroupement
ORDER BY liste_Tri

 AS : alias donner un nouveau nom à SELECT * FROM Users as U;

la table (n’est pas obligatoire) Select * from Users U

 [DISTINCT] : afficher le résultat sans SELECT DISTINCT ville FROM Users

doublant
 WHERE : définir la liste des SELECT * FROM Users where age=12
conditions
 GROUP BY : regrouper un ensemble SELECT * FROM Users groupe by ville, age;
de ligne par valeurs de colonnes.
 Having : la condition de
Select * FROM Users groupe by ville having age
regroupement. >=20
 ORDER BY : trie dans l’ordre croissant
Select * FROM Users groupe by ville having age
ou décroissant, par défaut croissant>=20
Order by age ASC, ville DESC;
 INNER JOIN … ON : Joint deux tables Exemple : sélectionne les noms des employés ainsi
en fonction d'une condition connue que les noms des départements
sous le nom de prédicat de jointure
(Pas des valeurs null) Select e.nom, d.nom FROM employés e INNER JOIN
départements d ON e.id = d.id;

 LEFT JOIN (OU LEFT OUTER JOIN): Select e.nom, d.nom FROM employés e LEFT JOIN
Cette jointure renvoie toutes les départements d ON e.id = d.id;
lignes de la table de gauche, même
s'il n'y a pas de correspondance dans Remarque : LEFT OUTER et RIGHT OUTER n’est pas
la table de droite. Si aucune supporté par MYSQL
correspondance n'est trouvée, les
valeurs de la table de droite seront
NULL.

 RIGHT JOIN (OU RIGHT OUTER JOIN): Select e.nom, d.nom FROM employés e RIGHT JOIN
Cette jointure renvoie toutes les départements d ON e.id = d.id;
lignes de la table de droite, même s'il
n'y a pas de correspondance dans la
table de gauche. Si aucune
correspondance n'est trouvée, les
valeurs de la table de gauche seront
NULL.

 CROSS JOIN : Cette jointure renvoie Exemple : Cette requête renverra toutes les
le produit cartésien des deux tables, combinaisons possibles de noms d'employés et de
c'est-à-dire toutes les combinaisons noms de projets, créant un tableau avec toutes les
possibles de lignes entre les deux associations possibles
tables. Sans ON
SELECT e.nom, p.nom FROM employés e CROSS JOIN
projets p;

20
  SELF JOIN ( table réflexive) : Cette Exemple : Cette requête sélectionne le nom d'un
jointure renvoie le produit cartésien employé et le nom de son manager. (inner join , left
des deux tables, c'est-à-dire toutes join , right join)
les combinaisons possibles de lignes
entre les deux tables. SELECT e1.nom AS employé, e2.nom AS manager
FROM employés e1 INNER JOIN employés e2 ON
e1.manager_id = e2.id;
Les requêtes préparées : (pour tous les -- Préparation de la requête
requête : select, insert, delete, update) PREPARE reqt FROM
'SELECT id, nom FROM client WHERE id = ?';
-- utilisation de la requête prépare plusieurs foi :
SET @id = 1;
EXECUTE reqt USING @id;
-- Libération de la requête préparée
DEALLOCATE PREPARE reqt;

Création des index : Exemple cas 1 :

 Pendant la création de la table :
CREATE TABLE nom_table ( CREATE TABLE clients (
col1 TYPE, id INT PRIMARY KEY,
…. nom VARCHAR(100),
INDEX (liste_colonne) ville VARCHAR(100),
); INDEX (nom, ville)
 Après la création de la table : );
CREATE [UNIQUE | FULLTEXT | SPATIAL]
INDEX nomIndex Exemple cas 2 :
[USING BTREE | HASH]
ON [nomBase.]nomTable (colonne1 [(taille1)] CREATE UNIQUE INDEX code_client_unique
[ASC | DESC], colonne2 [(taille2)] [ASC | ON ecole.clients (code_produit);
DESC], ...);
Exemple cas 3 :
 En modifiant la table :
ALTER TABLE nom_table ADD INDEX ALTER TABLE clients ADD UNIQUE INDEX
nom_index (liste_colonne); unique_nom_index (nom);

Suppression d’un index : Exemple:

DROP INDEX nom_index ON nom_table; DROP INDEX code_client_unique ON clients;
Importation d’une Database : mysql -u utilisateur -p nom_base_de_données <
fichier_dump.sql
Exportation de Database : mysqldump -u utilisateur -p nom_base_de_données
> fichier_dump.sql

Requetés de l’union :

requete Explication
UNION : combiner les résultats de deux ou SELECT id, name FROM employees
plusieurs requêtes SELECT en une seule, en UNION
supprimant les doublons. SELECT id, name FROM managers;

21
UNION ALL (avec doublons) SELECT id, name FROM employees
UNION ALL
SELECT id, name FROM managers;

INTERSECT renvoie les valeurs communes (ou SELECT column_name(s) FROM table1
l'intersection) entre deux ensembles de résultats INTERSECT
de requêtes SELECT SELECT column_name(s) FROM table2;

MINUS permet de renvoyer les résultats de la SELECT column_name(s) FROM table1

première requête SELECT en excluant ceux qui MINUS
apparaissent dans la deuxième requête SELECTE. SELECT column_name(s) FROM table2;

Création des conditions avec les expressions suivantes :

Les opérateurs arithmétiques -,*,\,+,%

Les opérateurs Comparaisons <,>,<=,>=, <>, =
Les opérateurs logiques et les sous requête
ALL(sous_requete) : TRUE si tous les Exemple : sélectionne tous les produits dont le prix est
éléments d'un jeu de comparaisons sont supérieur à tous les prix des produits de la catégorie
TRUE. 'Livres'.

SELECT * FROM produits WHERE prix > ALL (SELECT prix

FROM produits WHERE catégorie = 'Livres');

AND : TRUE si les deux expressions Exemple : Sélectionne les employés dont le salaire est
booléennes sont TRUE. supérieur à 50 000 et qui travaillent dans le
département 'Informatique'.

SELECT * FROM employés WHERE salaire > 50000 AND

département = 'Informatique';

ANY (sous_requete) : TRUE si n'importe Exemple : Sélectionne les produits dont le prix est
quel élément d'un jeu de comparaisons supérieur à n'importe quel prix des produits de la
est TRUE. catégorie 'Électronique'.

SELECT * FROM produits WHERE prix > ANY (SELECT

prix FROM produits WHERE catégorie = 'Électronique');

BETWEEN : TRUE si l'opérande est situé Exemple : Sélectionne les produits dont le prix est
dans une certaine plage. compris entre 100 et 500

SELECT * FROM produits WHERE prix BETWEEN 100

AND 500;

EXISTS (sous_requete) : TRUE si une Exemple : sélectionne les clients qui ont passé au
sous-requête contient des lignes. moins une commande

NOT EXISTS dans le cas contraire.

22
 SELECT * FROM clients WHERE EXISTS (SELECT *
FROM commandes WHERE clients.id =
commandes.client_id);

IN (sous_requete) : TRUE si l'opérande Exemple : sélectionne les employés qui travaillent dans
est égal à un élément d'une liste les départements 'Informatique' ou 'Marketing'.
d'expressions. NOT IN dans le cas
contraire SELECT * FROM employés WHERE département IN
('Informatique', 'Marketing');
LIKE : TRUE si l'opérande correspond à un Exemple : sélectionne les clients dont le nom
modèle. Not Like dans le cas contraire. commence par 'Jean'.
Les Jocker : % plusieurs caractères.
_ un seul caractère. SELECT * FROM clients WHERE nom LIKE 'Jean%';
Les regex : [ ], [^]

NOT : Inverse la valeur de tout autre Exemple : sélectionne les produits dont le prix n'est pas
opérateur booléen. inférieur à 50.

SELECT * FROM produits WHERE NOT prix < 50;

OR : TRUE si l'une ou l'autre expression Exemple : sélectionne les employés qui travaillent soit
booléenne est TRUE. dans le département 'Informatique', soit dans le
département 'Ventes'.

SELECT * FROM employés WHERE département =

'Informatique' OR département = 'Ventes';

SOME (sous_requete) : TRUE si certains Exemple : sélectionne les produits dont le prix est
éléments d'un jeu de comparaisons sont supérieur à certains des prix des produits de la
TRUE catégorie 'Jouets'.

SELECT * FROM produits WHERE prix > SOME (SELECT

prix FROM produits WHERE catégorie = 'Jouets');

Les fonctions Mathématiques :

Fonction Explication Resultat

ABS() : Retourne la valeur absolue d'un nombre SELECT ABS(-15) AS valeur_absolue; 15
CEIL() : Renvoie la plus petite valeur entière SELECT CEIL(4.3) AS valeur_ceil; 5
supérieure ou égale au nombre d'entrée
FLOOR() : Renvoie la plus grande valeur entière SELECT FLOOR(4.9) AS valeur_floor; 4
non supérieure au nombre d'entrée.
MOD() : Renvoie le reste d'un nombre divisé par SELECT MOD(10, 3) AS reste; 1
un autre (modulo)
ROUND() : Arrondit un nombre à un nombre SELECT ROUND(3.456, 2) AS arrondi; 3.46
spécifié de places décimales
TRUNCATE() : Tronque un nombre à un nombre SELECT TRUNCATE(3.456, 2) AS tron; 3.45
spécifié de places décimales sans arrondir. SELECT TRUNCATE(3.456, 0) AS tron; 3

23
 Les fonctions de CDC:

CONCAT() : Concaténer deux ou SELECT CONCAT('Hello', ' ', 'World') AS Hello World
plusieurs chaînes en une seule resultat;
chaîne.
UPPER() : Convertir une chaîne SELECT UPPER('hello world') AS majuscule; HELLO
en majuscule. WORLD
LENGTH() : Obtenir la longueur SELECT LENGTH('Bonjour') AS longueur; 7
d'une chaîne en octets.
LEFT() : Obtient un nombre SELECT LEFT('Hello World', 5) AS Hello
spécifié de caractères les plus à partie_gauche;
gauche d'une chaîne.
LOWER() : Convertir une chaîne SELECT LOWER('HELLO WORLD') AS hello world
en minuscule. minuscule;
LTRIM() : Supprimer tous les SELECT LTRIM(' Hello World') AS resultat; Hello World
espaces du début d'une chaîne.
REPLACE() : Recherche et SELECT REPLACE('Hello World', 'World', 'SQL') Hello SQL
remplace une sous-chaîne dans AS resultat;
une chaîne.
RIGHT() : Retourne un nombre SELECT RIGHT('Hello World', 5) AS World
spécifié de caractères les plus à partie_droite;
droite d'une chaîne.
RTRIM() : Supprime tous les SELECT RTRIM('Hello World ') AS resultat; Hello World
espaces de la fin d'une chaîne.
SUBSTRING() : Extraire une sous- SELECT SUBSTRING('Hello World', 7, 5) AS World
chaîne à partir d'une position sous_chaine;
avec une longueur spécifique.
TRIM() : Supprime les caractères SELECT TRIM(' Hello World ') AS resultat; Hello World
indésirables d'une chaîne
(espaces au début et à la fin)
FORMAT() : Mettre en forme un SELECT FORMAT(12345.678, 2) AS 12,345.68
nombre avec une locale nombre_formate;
spécifique, arrondi au nombre de
décimales
INSTR() : Renvoie la position de la SELECT INSTR('Hello World', 'World') AS 7
première occurrence d'une sous- position;
chaîne dans une chaîne.
FIND_IN_SET() : Rechercher une SELECT FIND_IN_SET('orange', 2
chaîne dans une liste de chaînes 'apple,orange,banana') AS position;
séparées par des virgules
SUBSTRING_INDEX() : Renvoie SELECT SUBSTRING_INDEX apple,orange
une sous-chaîne à partir d'une ('apple,orange,banana', ',', 2) AS sous_chaine;
chaîne avant un nombre spécifié
d'occurrences d'un délimiteur.

Les fonctions de date:

Fonction Explication Résultat
CURDATE() : Renvoie la date actuelle SELECT CURDATE(); 2024-10-14

24
DATEDIFF() : Calcule le nombre de SELECT DATEDIFF('2024-12-31', '2024-10- 78
jours entre deux dates 14');
DAY() : Obtient le jour du mois d'une SELECT DAY('2024-10-14'); 14
date spécifiée
DATE_ADD() : Ajoute une valeur de SELECT DATE_ADD('2024-10-14', 2024-10-24
temps à une date INTERVAL 10 DAY);
DATE_SUB() : Soustrait une valeur de SELECT DATE_SUB('2024-10-14', 2024-10-07
temps d'une date INTERVAL 7 DAY);
DATE_FORMAT() : Formate une date SELECT DATE_FORMAT('2024-10-14', Monday,
en fonction d'un format spécifié '%W, %M %d, %Y'); October 14,
2024
DAYNAME() : Renvoie le nom du jour SELECT DAYNAME('2024-10-14'); Monday
de la semaine pour une date
DAYOFWEEK() : Renvoie l'index du SELECT DAYOFWEEK('2024-10-14'); 2 (Lundi)
jour de la semaine (1 = Dimanche, 7 =
Samedi)
EXTRACT() : Extrait une partie d'une SELECT EXTRACT(YEAR FROM '2024-10- 2024
date, par exemple l'année 14');
LAST_DAY() : Renvoie le dernier jour SELECT LAST_DAY('2024-10-14'); 2024-10-31
du mois pour une date donnée
NOW() : Renvoie la date et l'heure SELECT NOW(); 2024-10-14
actuelles 14:35:21
MONTH() : Renvoie le mois d'une date SELECT MONTH('2024-10-14'); 10
(en entier)
STR_TO_DATE() : Convertit une chaîne SELECT STR_TO_DATE('14-10-2024', '%d- 2024-10-14
de caractères en date selon un format %m-%Y');
SYSDATE() : Renvoie la date et l'heure SELECT SYSDATE(); 2024-10-14
au moment où la requête est exécutée 14:35:21
TIMEDIFF() : Calcule la différence SELECT TIMEDIFF('12:00:00', '09:30:00'); 02:30:00
entre deux heures
TIMESTAMPDIFF() : Calcule la SELECT TIMESTAMPDIFF(MONTH, '2024- 9
différence entre deux dates (en mois 01-01', '2024-10-14');
dans cet exemple)
WEEK() : Renvoie le numéro de la SELECT WEEK('2024-10-14'); 41
semaine dans l'année
WEEKDAY() : Renvoie l'index du jour SELECT WEEKDAY('2024-10-14'); 0 (Lundi)
de la semaine (0 = Lundi, 6 =
Dimanche)
YEAR() : Renvoie l'année d'une date SELECT YEAR('2024-10-14'); 2024
spécifiée

Les fonctions de conversion:

Fonction Explication Résultat
TO_CHAR(nombre,format) : SELECT TO_CHAR(12345.678, '99999.99') 12345.68
convertir un nombre en chaîne de FROM dual;
caractères selon un format spécifique. SELECT TO_CHAR(7, '00000') FROM dual; 00007

TO_CHAR(date, format) : Cette SELECT TO_CHAR(SYSDATE, 'DD/MM/YYYY') 14/10/2024

fonction convertit une date en chaîne FROM dual;

25
de caractères selon le format de date SELECT TO_CHAR(SYSDATE, 'Month DD, October 14,
spécifié YYYY') FROM dual; 2024

TO_DATE(chaîne, format) : La SELECT TO_DATE('14-10-2024', 'DD-MM- 2024-10-14

fonction TO_DATE convertit une YYYY') FROM dual;
chaîne de caractères en une date SELECT TO_DATE('2024 Oct 14', 'YYYY Mon 2024-10-14
selon le format spécifié. DD') FROM dual;

TO_NUMBER(chaîne) : Cette fonction SELECT TO_NUMBER('12345.67') FROM 12345.67

convertit une chaîne de caractères en dual;
une valeur numérique. SELECT TO_NUMBER(' 6789 ') FROM dual; 6789

CAST() : convertir une expression d'un SELECT CAST(12345 AS CHAR); '12345'

type de données à un autre SELECT CAST('2024-10-14' AS DATE); 2024-10-14

CONVERT() : convertir une valeur SELECT CONVERT('2024-10-14', DATE); 2024-10-14

d'un type de données à un autre. SELECT CONVERT(12345, CHAR); '12345'

Les fonctions d’agrégation :

Fonction Explication Résultat
SUM() renvoie la somme des valeurs SELECT SUM(salary) FROM employees; 500000
dans une colonne numérique
AVG() renvoie la moyenne des SELECT AVG(salary) FROM employees; 50000
valeurs d'une colonne numérique
COUNT() renvoie le nombre de SELECT COUNT(*) FROM table_name; 10
lignes qui correspondent à une
condition donnée
MAX() renvoie la valeur maximale SELECT MAX(salary) FROM employees; 120000
dans une colonne.
MIN() renvoie la valeur minimale SELECT MIN(salary) FROM employees; 30000
dans une colonne.

c. LCD (MySQL)

Globale : *.* ;
DB : dbtest.*
Table : dbtest.Produits
Colonne : SELECT (Num_Produit,Description
Routine : GRANT EXECUTE ON PROCEDURE CPrix
Proxy : GRANT PROXY ON root

Créer un utilisateur :
CREATE USER 'alice'@'localhost' IDENTIFIED BY 'motdepasse';
Modifier un utilisateur :
ALTER USER 'alice'@'localhost' IDENTIFIED BY 'nouveaumotdepasse';
Renommer un utilisateur :

26
RENAME USER 'alice'@'localhost' TO 'bob'@'localhost';
Supprimer un utilisateur :
DROP USER 'bob'@'localhost';
Syntaxe des privilèges :
GRANT privilege1 [(liste_colonnes)], [privilege2 [(liste_colonnes)], ...] ON [type_objet]
niveau_privilege TO utilisateur [IDENTIFIED BY mot_de_passe];
Exemple :
GRANT SELECT, UPDATE (nom, prenom, adresse), DELETE, INSERT ON eshop_app_db.clients
TO 'saadi'@'localhost';
Accorder des privilèges
GRANT SELECT, INSERT ON ma_base.ma_table TO 'alice'@'localhost';
Accorder tous les privilèges
GRANT ALL PRIVILEGES ON ma_base.* TO 'alice'@'localhost';
Syntaxe pour Révoquer les privilèges (retirer le privilège)
REVOKE privilege [, privilege2, ...] ON niveau_privilege FROM utilisateur;
Exemple
REVOKE INSERT ON ma_base.ma_table FROM 'alice'@'localhost';

Créer un rôle :
CREATE ROLE 'manager';
Accorder des privilèges à un rôle :
GRANT SELECT, INSERT, UPDATE ON eshop_app_db.clients TO 'manager';
Attribuer un rôle à un utilisateur :
GRANT 'manager' TO 'alice'@'localhost';
Afficher les rôles d'un utilisateur :
SHOW GRANTS FOR 'alice'@'localhost';
Attirer un rôle a un utilisateur :
REVOKE '<role>' FROM '<user>'@'<host>';
Supprimer un rôle :
DROP ROLE 'manager';

18. SQL procédurale MySQL:

Les sous programmes :
C’est un bloc d’instructions qui peut être imbriqué dans un autre bloc qui contient les éléments
suivants :
- BIGIN : indiquer le début du bloc.
- DECLARE : optionnelle déclaration des variables, fonction, trigger….
- END : indique la fin du bloc
Exemple :

BEGIN
SELECT 'Bloc instructions1;
BEGIN
SELECT 'Bloc d''instructions2;
END;
BEGIN
SELECT 'Bloc d''instructions3';

27
 END;
END;

Les variables :
DECLARE nomVar [,nomVar2...] typeMySQL [DEFAULT expression];

Exemple:
DECLARE DateNai DATE;
DECLARE statut BOOLEAN DEFAULT TRUE;
DECLARE x,y,z INT;

Variable de session avec le symbole @:

SET @nomVariable := valeur ou bien SELECT @nomVariable := valeur

Les fonctions
Peut renvoyer caractère, entier…et non pas une table. Pour renvoyer une table il faut utiliser les
procédures stockées.
La syntaxe : Example:
DROP FUNCTION IF EXISTS nom_fonction;
CREATE FUNCTION nom_fonction (parameter) DROP FUNCTION IF EXISTS nbrclient;
RETURNS type_retour DELIMITER $$
BEGIN CREATE FUNCTION nbrclient (v VARCHAR(255))
-- Déclaration informative RETURNS INT
DECLARE variable_example TYPE; READS SQL DATA
BEGIN
-- Instructions DECLARE nombre INT;
SELECT 'Exécution des instructions ici'; -- Calcul du nombre de clients par ville
SET nombre = (SELECT COUNT(*)
RETURN type_retour; FROM clients
END; WHERE adresse = v);
RETURN nombre;
READS SQL DATA : lire les données END $$
MODIFIES SQL DATA : modifie les données DELIMITER ;
CONTAINS SQL : elles ne lisent ni ne modifie
DELIMITER $$ : c’est comme point-virgule à la Appel de la fonction:
fin d’une instruction il permet l’exécution des
instructions comme un seul bloc SELECT nbrclient ('Rabat');

Les procédures stockées

- Les procédures stockées permettent de stocker un ensemble de requêtes SQL, à exécuter
en cas de besoin.
- La procédure stockée peut également exécuter une autre procédure stockée ou une
fonction.
- La procédure stockée a trois directions :
o IN : (par défaut) Paramètre d'entrée accessible en lecture seule dans la PS
o OUT : Paramètre de sortie pour retourner une valeur de la procédure à l'appelant.
o INOUT : Paramètre d'entrée et de sortie passer une valeur à la procédure ou
fonction et retourner une valeur modifiée à l'appelant

Syntaxe Exemple avec IN:

DELIMITER $$ DELIMITER $$

28
CREATE PROCEDURE nom_procedure (param1 CREATE PROCEDURE ps_client(IN ville
INT, param2 VARCHAR(50)) VARCHAR(255))
BEGIN BEGIN
-- Code SQL à exécuter SELECT * FROM clients
SELECT * FROM table WHERE colonne1 = WHERE UPPER(adresse) = UPPER(ville);
param1 AND colonne2 = param2; END $$
END $$ DELIMITER ;
Appel de la PS:
DELIMITER ; CALL ps_client ('Rabat');

Exemple avec OUT : Exemple avec INOUT :

DELIMITER // DELIMITER //

CREATE PROCEDURE psClient(IN v CREATE PROCEDURE SetCounter(INOUT counter

VARCHAR(255), OUT nbrCl INT) INT, IN inc INT)
BEGIN BEGIN
SELECT COUNT(*) INTO nbrCl FROM clients SET counter = counter + inc;
WHERE adresse = v; END //
END //
DELIMITER ;
DELIMITER ;
Appel de la PS:
Appel de la PS: SET @counter = 0;
CALL psClient ('rabat', @total); CALL SetCounter(@counter, 7);
SELECT @total; SELECT @counter;

Suppression d’une procédure stockée : DROP PROCEDURE [IFEXISTS] nom_procedure_stockée;

Lister les procedures stockée: SHOW PROCEDURE STATUS [LIKE 'pattern' | WHERE condition]

Structure de contrôle conditionnelle

IF IF-ELSE IF-ELSEIF-ELSE
IF condition THEN IF condition THEN IF condition 1 THEN
instructions instructions instructions
END IF ELSE ELSEIF condition 2 THEN
instructions instructions 2
END IF ELSE
instructions 3
END IF
Case sans sélecteur Case avec sélecteur
CASE CASE variable_selector
WHEN condition 1 THEN WHEN expr1 THEN instructions1
instructions 1 WHEN expr2 THEN instructions2
WHEN condition 2 THEN ...
instructions 2 WHEN exprN THEN instructionsN
... [ELSE instructionsN+1]
WHEN condition N THEN END CASE
instructions N
[ELSE instructions N+1]
END CASE

29
 Structure de contrôle itératives
LEAVE : Qui sort d’une boucle (ou d’un bloc étiqueté)
ITERATE : Qui force le programme à refaire un tour de boucle depuis le début
LOOP WHILE REPEAT
[label_debut:] LOOP [label_debut:] WHILE condition DO REPEAT
statement_list list_of_instructions list_of_instructions
END LOOP [label_fin] END WHILE [label_fin] UNTIL condition

Les exceptions
En MySQL, les exceptions sont gérées à travers des conditions et des gestionnaires d'exceptions
(handlers) dans les procédures stockées.

Syntaxe 1:
DECLARE handler_action HANDLER
FOR condition_value [, condition_value ...]
statement;

Handler_action: {
CONTINUE
| EXIT
| UNDO
}
Condition_value: {
mysql_error_code
| SQLSTATE [VALUE] sqlstate_value
| condition_name
| SQLWARNING
| NOT FOUND
| SQL EXCEPTION
}

Explication :
handler_action : C'est l'action à entreprendre si la condition est rencontrée.
 CONTINUE : Continue l'exécution après le gestionnaire.
 EXIT : Termine l'exécution du bloc ou de la procédure après avoir exécuté le gestionnaire.
 UNDO : Non supporté dans MySQL (présent dans la documentation SQL standard, mais
non implémenté dans MySQL).

condition_value : Vous pouvez intercepter différentes erreurs ou conditions en utilisant un ou

plusieurs de ces éléments :
 mysql_error_code : Un code d'erreur MySQL spécifique (par exemple 1062 pour une
violation de clé unique).
 SQLSTATE VALUE : Un code standard SQLSTATE (par exemple '23000' pour une violation
de contrainte).
 condition_name : Un nom de condition personnalisé que vous avez déclaré avec DECLARE
CONDITION.
 SQLWARNING : Capture tous les avertissements SQL.
 NOT FOUND : Capture les situations où aucune ligne n'est trouvée.
 SQLEXCEPTION : Capture toutes les erreurs SQL non spécifiquement traitées.

Syntaxe 2:

30
DECLARE nomException CONDITION FOR
SQLSTATE 'valeur_sqlstate' | code_erreur_mysql;

Syntaxe 3 :
L'instruction SIGNAL peut être utilisée pour lever des exceptions personnalisées en MySQL avec
des informations supplémentaires.
SIGNAL SQLSTATE 'sqlstate_value' SET info_1 = valeur_1, info_2 = valeur_2, ...;
L'instruction RESIGNAL en MySQL est utilisée pour relancer une exception qui a été capturée dans
un gestionnaire d'exceptions
RESIGNAL [SQLSTATE 'sqlstate_value'] [SET MESSAGE_TEXT = 'message_text', info_1 = val_1, ..]

Example 1 :
CREATE PROCEDURE insert_with_continue()
BEGIN
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
BEGIN
SELECT 'Une erreur est survenue, mais l\'exécution continue.';
END;
SELECT 'Suite de l\'exécution après l\'erreur.';
END;
Example 2 :
CREATE PROCEDURE insert_with_exit()
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
SELECT 'Une erreur est survenue. L\'exécution est interrompue.';
END;
SELECT 'Cette ligne ne sera pas exécutée si une erreur se produit.';
END;
Example 3 :
CREATE PROCEDURE insert_with_named_exception()
BEGIN
DECLARE duplicate_key CONDITION FOR SQLSTATE '23000';
DECLARE EXIT HANDLER FOR duplicate_key
BEGIN
SELECT 'Erreur : Violation de clé unique, insertion échouée.';
END;
INSERT INTO employees (id, name) VALUES (1, 'John');
SELECT 'Cette ligne ne sera pas exécutée si une erreur se produit.';
END;
Example 4 :
CREATE PROCEDURE ErreurA()
BEGIN
SELECT 'Une autre erreur est survenue';
END; //
DELIMITER ;
CREATE PROCEDURE ErreurB()
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
CALL ErreurA ();

31
 END;
DELIMITER ;

Example 5 :
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Erreur personnalisée levée', error_code = 1001,
error_details = 'Détails supplémentaires sur l\'erreur.';

Example 6 :
RESIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Une erreur SQL a été capturée et relancée.',
custom_info = 'Informations supplémentaires sur l\'erreur.';

Les Triggers (Déclencheurs)

Un déclencheur est une procédure stockée, dans la base de données, qui s'appelle
automatiquement à chaque fois qu'un événement spécial se produit sur la table à laquelle le
déclencheur est attaché.

Syntaxe:  CREATE TRIGGER nom_declencheur : Déclare un

CREATE TRIGGER nom_declencheur nouveau déclencheur avec le nom spécifié.
[ BEFORE | AFTER ] { INSERT | UPDATE |  [ BEFORE | AFTER ] : Indique si le déclencheur
DELETE } s'exécute avant ou après l'opération spécifiée
ON nom_table (INSERT, UPDATE, DELETE).
[ FOR EACH ROW ]  { INSERT | UPDATE | DELETE } : Spécifie
BEGIN l'opération qui déclenche le déclencheur.
-- corps_declencheur  ON nom_table : Indique la table sur laquelle le
END; déclencheur est défini.
 [ FOR EACH ROW ] : Indique que le déclencheur
doit s'exécuter pour chaque ligne affectée par
l'opération.
 BEGIN ... END : Définit le corps du déclencheur,
où vous pouvez écrire le code qui sera exécuté
lorsque le déclencheur est déclenché.
Les cas existents :
o Before insert
o After insert
o Before update
o After update
o Before delete
o After delete

Les notions OLD/NEW :

- Le mot-clé OLD fait référence aux valeurs d'une ligne avant qu'elle ne soit modifiée. (Pour
UPDATE et DELETE).
- Le mot-clé NEW permet d’accéder aux valeurs après l'opération. (pour INSERT et UPDATE).
Exemple :

CREATE TRIGGER insertion_clients

AFTER INSERT ON clients
FOR EACH ROW
BEGIN
INSERT INTO historique_modifications (client_id, ancienne_valeur, nouvelle_valeur,
date_modification, operation) VALUES (NEW.id, NULL, CONCAT(NEW.nom, ' ',

32
 NEW.prenom), NOW(), 'INSERT');
END;

Lister les Triggers : SHOW TRIGGERS;

Suppression d’un déclencheur : DROP TRIGGER [IF EXISTS] [nom_bd.nom_declencheur];

Les Curseurs
Un curseur est un objet utilisé dans les systèmes de gestion de bases de données (SGBD) pour traiter
et manipuler des ensembles de résultats de requêtes de manière plus contrôlée.
Syntaxe :
DECLARE nom_curseur CURSOR FOR instruction_SELECT;
OPEN nom_curseur;
FETCH nom_curseur INTO liste_variables;
CLOSE nom_curseur;

- DECLARE : Cette ligne déclare un curseur nommé nom_curseur pour une instruction SELECT
spécifiée (remplacez instruction_SELECT par votre requête SQL).
- OPEN : Cette commande ouvre le curseur, exécutant ainsi l'instruction SELECT et préparant
l'ensemble des résultats à être parcouru.
- FETCH : Cette instruction récupère la prochaine ligne de l'ensemble des résultats du curseur et
l'affecte aux variables spécifiées dans liste_variables.
- CLOSE : Cette commande ferme le curseur, libérant ainsi les ressources associées.
- DEALLOCATE : Les ressources sont libérées

Example:
DECLARE @nom VARCHAR(50);
DECLARE @prenom VARCHAR(50);

DECLARE mon_curseur CURSOR FOR

SELECT nom, prenom FROM clients WHERE ville = 'Paris';
OPEN mon_curseur;

FETCH NEXT FROM mon_curseur INTO @nom, @prenom;

WHILE @@FETCH_STATUS = 0
BEGIN
PRINT 'Nom: ' + @nom + ', Prénom: ' + @prenom;
FETCH NEXT FROM mon_curseur INTO @nom, @prenom;
END;

CLOSE mon_curseur;
DEALLOCATE mon_curseur;

Les transactions
Voici comment gérer les transactions dans SQL :

- Démarrer une Transaction : Utilisez START TRANSACTION ou BEGIN pour initier une
transaction.
- Effectuer des Opérations : Exécutez vos commandes SQL (INSERT, UPDATE, DELETE, etc.).

33
 - Valider la Transaction : Utilisez COMMIT pour valider les modifications et les rendre
permanentes.
- Annuler la Transaction : Si une erreur se produit ou si vous souhaitez annuler les modifications,
utilisez ROLLBACK.

Syntaxe et exemple :

-- Démarrer une transaction

START TRANSACTION;

-- Effectuer des opérations

INSERT INTO comptes (client_id, solde) VALUES (1, 1000);
UPDATE comptes SET solde = solde - 100 WHERE client_id = 1;

-- Vérifier si les opérations sont réussies

IF (SELECT solde FROM comptes WHERE client_id = 1) >= 0 THEN
-- Valider la transaction
COMMIT;
ELSE
-- Annuler la transaction
ROLLBACK;
END IF;

19. T-SQL (Transact-SQL) de Microsoft SQL Server :

Transact SQL est un langage procédural (par opposition à SQL qui est un langage déclaratif) qui permet
de programmer des algorithmes de traitement des données au sein des SGBD.

Les variables
- Le symbole @ commence le nom de toute variable.
- Le symbole dédoublé @@ commence le nom des variables globales du SGBDR.
- Le symbole # commence le nom de toute table temporaire.
- Le symbole dédoublé ## commence le nom de toute table temporaire globale.
- Une Variable est déclarée dans tous les endroits de code par l’instruction : DECLARE
DECLARE @nom varchar(32)
- Pour Assignée une variable en utilise l’instruction : SET
SET @nom = ‘alami’

- Pour Assignée une variable ou bien plusieurs en peuvent utiliser aussi SELECT de SQL

34
 Declare @nom varchar(20), @prenom varchar(20)
Select @nom=nom, @prenom=prenom from client where idClt = 1

Syntaxe de la structure IF …. ELSE ….:

IF [NOT] Example:
Condition instruction
[ELSE Instruction] DECLARE @nbr int
SET @nbr = (SELECT COUNT(CltID) FROM Clients)
Ou bien
IF(@nbr <10)
IF [NOT] EXISTS(requête select) PRINT ‘Plus de 10 Clients’
Instruction ELSE
[ELSE Instruction] PRINT ‘Moins de 10 Clients’

Syntaxe de la structure While

While [NOT] Condition instruction DECLARE @i int
SET @i = 0
Les instruction BREAK, CONTINUE WHILE @i <10
permettent respectivement BEGIN
d’interrompre ou de continuer une PRINT ‘i=’+ CONVERT(varchar(2), @i)
boucle. SET @i=@i+1
END

L’étiquette GOTO : Syntaxe de CASE

'instruction GOTO permet de rediriger Existe deux utilisation de CASE en T-SQL :
l'exécution du flux de contrôle vers une - Le CASE simple. Equivalente de Switch dans C
autre partie du script SQL à l'aide d'une - Le CASE de recherche.
étiquette
DECLARE @NmbE int, @NmbS varchar(20)
DECLARE @i int SET @NmbE = 42
SET @i = 0 SELECT @NmbS = CASE @NmbE
Debut:
WHEN 10 THEN ‘Dix’
PRINT 'Index=‘ +
WHEN 24 THEN ‘Vingt Quatre’
CONVERT(varchar(2),@i)
SET @i = @i + 1 Else ‘aucun’
If (@i!=10) End
goto debut Print ‘le nombre est ’+@NmbS

Les fonctions de base :

PRINT: est une instruction permettant d’afficher une ligne en sortie de procédure.
EXEC : est une instruction permettant de lancer une requête ou une procédure stockée.
USE : est une instruction permettant de préciser le nom de la base de données cible.

Définition de procédure Stockée:

CREATE PROCEDURE nomP Créer une Procédure:
@parametre1 type, Create procedure GetProductId As Select
@parametre2 type @prodid from product
AS Code Procédure
Modifier une procédure:

35
Appel d’une procédure Stockée: avec exec Alter procedure GetProductId As Select @prodid,
ou execute @prodName from product

Exec nomP Appel d’une Procédure avec Paramètres

exec getproductinfo @ prodid =10,
Avec paramètre : @ProdName=‘Maria’
Exec nomP @parametre1=val1, Ou bien
@parametre2=val2 exec getproductinfo 10, ‘Maria’

Définition de fonction:
Syntaxe d’une Fonction Scalaire Syntaxe d’une Fonction multi-lignes
create function Nom-fonction (para1 type1 create function Nom-fonction (para1 type1
,..., paraN typeN) ,..., paraN typeN)
returns type-resultat return @nom-table table (col1 type1,
as begin col2 type2,...)
...... as begin
return valeur-resultante ....
end return
end
example
Create function nbr-stg (@id-class int) example
returns int create function stg-M
as begin returns @stg table (id-stg int, nom
declare @nbr int varchar, prenom varchar)
select @nbr = count(*) from stagiaire as begin
where id-class = @id-class insert into @stg select * from
return @nbr stagiaire where nom like 'M%'
end return
end
Appel de la fonction : Appel de la fonction :
select dbo.nbr-stg(3) select select * from dbo.stg()
Curseurs
Types : Plusieurs types existent
• Curseurs à défilement en avant (Forward Only)
• Curseurs statiques (Static)
• Curseurs d'ensemble de valeurs clés (Keyset)
• Curseurs dynamiques (Dynamic)
• Déclaration d’un curseur:
Un curseur se définit dans une instruction DECLARE possédant une requête de type SELECT.
Il convient de définir pour chaque colonne renvoyé une variable de type approprié.
DECLARE @Col1 Type1, @Col2 Type2, @Col3 Type3 ...
DECLARE MyCursor CURSOR static | keyset | dynamic | For
SELECT COL1, COL2, COL3 …. FROM MyTable

• Ouvrir un curseur:
Pour lancer la requête associée (et donc placer les données dans les buffers appropriés) il
faut utiliser l'instruction OPEN.

36
OPEN MyCursor

• Lecture du premier enregistrement

Pour lire les données de la ligne courante et les associer aux variables du curseur il faut
utiliser l'instruction FETCH.
FETCH MyCursor INTO @Col1, @Col2, @Col3...

Atteindre le premier enregistrement du curseur

- Fetch First from nom_curseur into variable1, variable2,..
Atteindre l'enregistrement du curseur suivant celui en cours
- Fetch Next from nom_curseur into variable1, variable2,...
Ou Fetch nom_curseur into variable1, variable2…
Atteindre l'enregistrement du curseur précédent celui en cours
- Fetch Prior from nom_curseur into variable1, variable2,...
Atteindre le dernier enregistrement du curseur
- Fetch Last from nom_curseur into variable1, variable2,...
Atteindre l'enregistrement se trouvant à la position n dans le curseur
- Fetch absolute n from nom_curseur into variable1, variable2,...
Atteindre l'enregistrement se trouvant après n positions de la ligne en cours
- Fetch Relative Num_Ligne from nom_curseur into variable1, variable2,...

• Boucle de traitement:
WHILE @@fetch_Status = 0
BEGIN
traitement
-- lecture de l'enregistrement suivant
FETCH MyCursor INTO @Col1, @Col2, @Col3...
END

• Fermeture du curseur
CLOSE myCursor

• Libération de la mémoire
DEALLOCATE myCursor

Triggers (Déclencheurs)
 Créer trigger
CREATE TRIGGER <nom_trigger> ON <table_ou_vue>
FOR | AFTER | INSTEAD OF [ INSERT ] [ , ] [ UPDATE ] [ , ] [DELETE]
AS
<code>
 Supprimer trigger
DROP TRIGGER nom-trigger
 Activer et désactiver trigger
Alter table nom_table
Disable /Enable trigger nom_trigger

37
 Exceptions
Lever une exception Raiserror : RAISERROR (message_string, severity, state)

severity : Le niveau de gravité de l'erreur. Il s'agit d'une valeur numérique comprise entre 0 et 25.
 0 à 10 : Messages d'information ou d'avertissement.
 11 à 16 : Erreurs qui peuvent être corrigées par l'utilisateur.
 17 à 25 : Erreurs graves nécessitant une intervention administrative.
state : Un code de retour qui aide à identifier où l'erreur s'est produite. Il doit être compris entre 0
et 255.

Exemple :
RAISERROR ('les salaires pour job_id :%d doivent être entre %d et %d.', 16, 1, @JOB_ID,
@MIN_sal, @MAX_sal)

Structure du Bloc TRY...CATCH:

BEGIN TRY
-- Code qui peut générer une erreur
{ instructions SQL }
END TRY
BEGIN CATCH
-- Code pour gérer l'erreur
{ instructions SQL }
-- Optionnel : retourner des informations sur l'erreur
SELECT
ERROR_NUMBER() AS ErrorNumber,
ERROR_SEVERITY() AS ErrorSeverity,
ERROR_STATE() AS ErrorState,
ERROR_PROCEDURE() AS ErrorProcedure,
ERROR_LINE() AS ErrorLine,
ERROR_MESSAGE() AS ErrorMessage;
END CATCH

Transaction
- BEGIN TRANSACTION : Démarre une nouvelle transaction.
- COMMIT TRANSACTION : Valide toutes les modifications effectuées dans la transaction.
- ROLLBACK TRANSACTION : Annule toutes les modifications effectuées depuis le début de la
transaction.
BEGIN TRANSACTION;
-- Instructions SQL (INSERT, UPDATE, DELETE, etc.)
IF (/* condition pour valider */)
COMMIT TRANSACTION;
ELSE
ROLLBACK TRANSACTION;

20. PLSQL
PL/SQL (Procedural Language/SQL) est une extension procédurale de SQL, utilisée principalement dans
les bases de données Oracle.

38
Les variables : es variables sont déclarées dans la section DECLARE, et vous pouvez leur assigner
des valeurs via l'opérateur :=
DECLARE
my_string VARCHAR2(100) := 'Hello, World!';
BEGIN
DBMS_OUTPUT.PUT_LINE(my_string);
END;
Structures de contrôle : IF...THEN...ELSE
DECLARE
num NUMBER := 5;
BEGIN
IF num > 10 THEN
DBMS_OUTPUT.PUT_LINE('Greater than 10');
ELSE
DBMS_OUTPUT.PUT_LINE('10 or less');
END IF;
END;
Boucles (LOOP, WHILE, FOR) :
BEGIN
FOR i IN 1..5 LOOP
DBMS_OUTPUT.PUT_LINE('Iteration: ' || i);
END LOOP;
END;
Procédures stockées :
CREATE OR REPLACE PROCEDURE greet_user (name IN VARCHAR2) AS
BEGIN
DBMS_OUTPUT.PUT_LINE('Hello, ' || name);
END;
Appel de la procédure :
BEGIN
greet_user('Alice');
END;
Fonctions stockées :
CREATE OR REPLACE FUNCTION add_numbers (a IN NUMBER, b IN NUMBER) RETURN NUMBER AS
BEGIN
RETURN a + b;
END;
Appel de la fonction :
DECLARE
result NUMBER;
BEGIN
result := add_numbers(10, 20);
DBMS_OUTPUT.PUT_LINE('Result: ' || result);
END;
Gestion des exceptions
BEGIN
DBMS_OUTPUT.PUT_LINE(10 / 0);
EXCEPTION
WHEN ZERO_DIVIDE THEN
DBMS_OUTPUT.PUT_LINE('Cannot divide by zero');
END;

39
Curseurs :

DECLARE
CURSOR my_cursor IS SELECT name FROM employees;
employee_name employees.name%TYPE;
BEGIN
OPEN my_cursor;
LOOP
FETCH my_cursor INTO employee_name;
EXIT WHEN my_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE('Employee: ' || employee_name);
END LOOP;
CLOSE my_cursor;
END;
Triggers
CREATE OR REPLACE TRIGGER trigger_name
{BEFORE | AFTER} {INSERT | UPDATE | DELETE} ON table_name
[FOR EACH ROW]
DECLARE
-- Déclaration de variables (optionnelle)
BEGIN
-- Corps du trigger
-- Code PL/SQL à exécuter
END;

Transactions

DECLARE
v_employee_id employees.employee_id%TYPE := 100;
v_salary employees.salary%TYPE := 60000;
BEGIN
-- Démarrer une transaction
INSERT INTO employees (employee_id, salary) VALUES (v_employee_id, v_salary);
-- Imaginons qu'une condition doit être vérifiée avant de valider
IF v_salary > 50000 THEN
-- Valider la transaction
COMMIT;
DBMS_OUTPUT.PUT_LINE('Transaction committed successfully.');
ELSE
-- Annuler la transaction
ROLLBACK;
DBMS_OUTPUT.PUT_LINE('Transaction rolled back.');
END IF;
EXCEPTION
WHEN OTHERS THEN
-- En cas d'erreur, annuler la transaction
ROLLBACK;
DBMS_OUTPUT.PUT_LINE('An error occurred, transaction rolled back.');
END;

40
 21. NoSQL avec MongoDB:
a. Définition de NoSQL:
Le SGBDR est un système limité face au donnée massive (Big Data) qui se caractérise par les 3V (Volum,
Velocity et Veracity). C’est pourquoi le NoSQL (Not Only SQL) permet de gérer ce type des données.

Les serveurs de données NoSQL se caractérisent par des architectures distribuées pour répondre aux
problématiques du Big Data.

Parmi les caractéristiques de NoSQL sont:

- Les données sont représentées sous forme de collections de paires clé-valeur, de documents,
de graphes, etc...
- La Scalabilité (mise à l’échelle) horizontale.
- En cas de panne d’un serveur, cette dernière serra remplace automatiquement par un autre.
- Utilisé pour les données semi structure ou non structure.
- Utilisé pour l’ensembles de données volumineux et hiérarchiques.
- Repose sur les propriétés BASE (Basically Available, Soft state,Eventualy Consistent) au lieu
de ACID.
- Les bases NoSQL privilégient la disponibilité à la cohérence : AP (Avaibility + Partition
tolérance) selon la théorème CAP (Consistency, Aviability, Partition tolerance)

b. Les types de base NoSQL :

Le NoSQL est un ensemble de technologies de BD dans la suite de ce document en va utiliser MongoDB
qui vient du terme Humongous DB qui veut dire une base de données gigantesque:

Bases de données Clé-Valeur - Dynamo DB

- Berkeley DB ou BDB
- Voldemort
- Riak DB
Bases de données orientées Document - Mongo DB
- CouchDB
- RavenDB
- Cassandra
Bases de données orientées Colonne - BigTable DB
- HBase
- SparkSQL
- Elasticsearch db
Bases de données orientées Graphe - Neo4j

c. Installation de Mongo DB :
Etape 1 : Télécharger le serveur depuis l’adresse suivante
https://www.mongodb.com/try?jmp=nav#community
Etape 2 : Lancer le serveur avec le service mongod.exe qui existe dans le fichier suivant :
C:\Program Files\MongoDB\Server\6.0\bin
Etape 3 : Sous Windows en va installer l’interface utilisateur : Studio 3T
Etape 4 : En teste le service Mongodb est en cours d’exécution sur le port 27017
Etape 5 : En lance l’ILE IntelliShell de Studio 3T
Etape 6 : En exécute la commande : db.help()
Etape 7 : En teste la commande : show dbs pour afficher les bases de donnée existent dans MongoDB

41
 d. Les notions NoSQL :
 Une base de donnée contient une collection des documents.
 Une collection est comme une table dans une BD relationnel sauf la collection n’a pas de
schéma et contient un ensemble des documents.
 Un document est équivalent à un enregistrement dans une table, il est ce format Json et
caractérise par un champ _id c’est un champ obligatoire.
 Une collection peut avoir des documents de même schéma ou bien des schémas différents

e. Les types des données :

Dans MongoDB, les documents sont stockés dans BSON, le format codé binaire de JSON, elle prend
en charge divers types de données à savoir :

String {"_id":"122", "prenom":"Amina"}

Integer: {"_id":"135", "age":22}
Double {"_id":"123","prixUni":14.25}
Boolean: {"_id":"123","statut":14.25}
Date {"Date_1": Date(),
"Date_2": new Date(),
"Date_3": "2023-12-12"}
Null {"_id":"123",
"prenom": null}
Données binaires {"_id":"123",
"BinaryValues": "10010001",}
Array: {"_id":"123",
"arrayValues": [ "1", "2", "3" ]}
ObjectId (Id d’objet): {"_id" :ObjectId("62dd128a1a19f3d7ecc6624f"),
"prenom" : "souad"}
MongoDB crée automatiquement un identifiant d’objet unique _id s’il n’est pas créé explicitement.

f. Les requête NoSQL :

Création de data base use myDB
Afficher la liste des DB show dbs
Afficher les collections d’une DB show collections
supprimer la DB courante db.nomcollection.drop()
supprimer une collection d’une DB db.dropDatabase()
Ajouter un document a une db.nomCollection.insert( {
collection "id" : "Sanaa",
"filiere" : "Dev Digital",
"niveau" : "2A",
"option":"Mobile" })
Espace de nom nomDB.nomCollections
Notion d’Embedding (Encapsulation) {
"_id": ObjectId("6347a9f7f0834a0011fa9f33"),
"name": "John Doe",
"email": "[email protected]",
"orders": [
{
"order_id": 1234,
"date": "2023-09-25",

42
 "amount": 99.99
},
{
"order_id": 5678,
"date": "2023-10-01",
"amount": 149.99
}
]
}
Notion de Linking (Référencement) {
"_id": ObjectId("6347a9f7f0834a0011fa9f33"),
"name": "John Doe",
"email": "[email protected]"
}
{
"_id": ObjectId("8767a9f7f0834a0011fa9f57"),
"order_id": 1234,
"user_id": ObjectId("6347a9f7f0834a0011fa9f33"),
"date": "2023-09-25",
"amount": 99.99
},
{
"_id": ObjectId("8777a9f7f0834a0011fa9f59"),
"order_id": 5678,
"user_id": ObjectId("6347a9f7f0834a0011fa9f33"),
"date": "2023-10-01",
"amount": 149.99
}

g. Les requetés de manipulation NoSQL et fonctions :

Insertion db. NomCollection.insert({"cle1" :"valeur1","cle2" :"valeur2"})
Exemple :
db.Etudiants.insert({"prenom":"Amina","age":25},{"prenom":"aya","age":25})
db. NomCollection.insertOne({"cle1" :"valeur1"})
Exemple :
db.Etudiants.insert({"prenom":"Amina","age":25})
db. NomCollection.insertMany({"cle1" :"valeur1","cle2" :"valeur2"})
Exemple :
db.Etudiants.insert({"prenom":"Amina","age":25},{"prenom":"aya","age":25})
suppression db. NomCollection.drop()
db. NomCollection.deleteOne({"cle1" :"valeur1"})
db. NomCollection.deleteMany({"cle1" :"valeur1","cle2" :"valeur2"})

remplacement db. NomCollection.update(old, new)

Exemple :
db.Filieres.update({"_id":"ID","nom":"old"},{"_id":"ID","nom":"new","nbr":3}
)
db.Filieres.update(
{"_id":"ID", "intitule":"Infrastructure digitale"},

43
 {"_id":"ID", "intitule":"Infrastructure digitale", "nbOptions":3} ,
{multi: true}
) //pour une modification multiple

modification db.Filieres.update(
{"intitule" : "Developpement digital"},
{$set: {"organisme": "OFPPT"}},
{multi: true}
)

sélection Sélectionner le 1ere élément :

db. NomCollection.findOne({"champ1":"val1","champ2":"val2"})

Sélectionner tous les éléments :

db. NomCollection.find({"champ1":"val1","champ2":"val2"})

Restriction Sélectionner tous les éléments et affiche que champ1 et champ2 :

db. NomCollection.find( {},{"champ1":1,"champ2":1})

Sélectionner un seul élément et affiche que le champ1 et masquer le _id:

db. NomCollection.findOne( {},{"champ1":1, "_id":0})

Projection selection = {"champ1": "val1","champ2":"val2"}

projection= {"champ1": 1,"_id":0}
db. NomCollection.find( selection, projection)

Fonction distinct db. NomCollection.distinct("champ1")

Fonction count db. NomCollection.find().count()

db. NomCollection.find({"champ1":"value"}).count()

Fonction limit db. NomCollection.find ({},{"champ1":val1,"_id":0}).limit(2)

Fonction sort db. NomCollection.find ({},{"champs1":value1,"_id":0}).sort()

db.NomCollection.find({},{"champs1":value1,"_id":0}).sort({"champ1":-1,})

h. Les opérateurs NoSQL :

égal à : = $eq Exemple:
supérieur à : > $gt selection = {"note":{"$gte":10.00}}
supérieur ou égal à : >= $gte db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0})
inférieur à : < $lt
inférieur ou égal à : <= $lte
différent de : ≠ $ne
Appartient à la liste $in Exemple:
N’appartient pas à la liste $nin selection = {"option":{"$in":["A","B"]}}
db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0})

44
ET Logique $and Exemple:
OU Logique $or s = { "$or": [ { "note" : { "$gte" : 10 } }, {"option":"A"} ] }
Not (OU Logique) $nor db.Etudiants.find(s,{"nom":1,"prenom":1,"_id":0})

Teste la présence ou non $exists Exemple:

d’un champ selection = { "option": {$exists : false }}
db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0})

Les Opérateurs Ce calcul s’effectue avec la fonction aggregate() qui prend en paramètre
d’agrégation : un tableau d’opérations (pipeline).

L'output de chaque opération du pipeline sera l'input de l'opération

suivante, pour produire une nouvelle collection.

Chaque étape du pipeline est définie par un opérateur passé à la

commande d’agrégation suivante.

db. NomCollection.aggregate([operateur1,operateur2,..])

Opérateur d’agrégation : Filtrer les documents de la collection suivant la sélection fournie à

$match l’opérateur $match

db. NomCollection.aggregate([{$match: {selection}}])

example:
db.Etudiants.aggregate([{$match: {"filiere.intitule" : "arabe" }}])

Opérateur d’agrégation : Permet d’effectuer des regroupements et faire des opérations

$group d'accumulation sur les documents (GROUP BY en SQL).

Le champ de regroupement est indiqué par id.

On peut faire tous les calculs d’agrégats classique en utilisant les fonctions
d’agrégation suivantes: $sum (somme), $avg (moyenne), $min
(minimum), $max (maximum)

db. NomCollection.aggregate ([ {$group: {_id: $champ_regroupement,

variable: { fonctionAggregation : $champ }, ...} } ])

example:
db.Etudiants.aggregate ([
{$group: {_id: "$filiere.intitule", total : {$sum:"$note"}}} ])

db.Etudiants.aggregate ([
{$group: {_id: "$filiere.intitule", maximum : {$max:"$note"}}} ])

db.Etudiants.aggregate([
{$group: {_id: "$filiere.intitule", maximum :{$max:"$note"}}},
{$sort: { maximum:1}} ])

45
 i. Les requetés via python:
Pour travailler les requetés NoSQL dans MongoDB avec python il faut installer la bibliothèque
PyMongo. C’est une librairie Python native.

Etape1 : vérification de l’installation de Python avec la commande : python –version

Etape2 : vérification de l’installation de pip avec la commande pip –version

Etape3 : saisir la commande suivante dans un terminal (invité de commande par exemple)
pip install pymongo

Etape4 : Créer la connexion avec le serveur MongoDB Pour effectuer cette connexion on utilise
MongoClient, qui se connecte, par défaut, à l'instance MongoDB s'exécutant sur
localhost:27017. Pour lancer la commande : mongod

Etape5 : en lance URL suivant : mongodb://localhost:27017/

Etape6 : lancer la commande : python

Etape7 : lancer le code suivant pour vérifier la connexion:

from pymongo import MongoClient
# Connexion au serveur MongoDB local
client = MongoClient("mongodb://localhost:27017/")
# Sélectionner ou créer une base de données
db = client["nom_de_votre_base_de_donnees"]
# Affichage des collections disponibles
print(db.list_collection_names())

Etape8 : Commencer à pratiquer les requetés, les requetés en le syntaxe suivante :

Client.baseDonnees.nomDeLaCollection.requete()

db.Stagiaires.find()
Retourne un curseur (type Cursor) sur les données

resultat = db.Etudiants.find() Pour afficher les données et faut parcourir le curseur

for r in resultat[:2]:
print(r)

46
selection={}
selection["option"]="Mobile"
resultat =db.Etudiants.find(selection)
for i in resultat[:]:
print(i)

projection={"nom":1,"prenom":1,"_id":0}
selection={}
selection["filiere.intitule"]="DD"
r =db.Etudiants.find(selection,projection)
for i in resultat[:]:
print(i)

r = db.Etudiants.find().sort("nom",-1)
for i in r[:]:
print(i)

for k,v in Retourne la liste des index de la collection

db.Etudiants.index_information().items():
print("index:" ,k, "valeur :",v,"\n")

db.Etudiants.create_index("i1") Création d’un index

db.Etudiants.drop_index("i1") Suppression d’un index

insert_one() - Insertion d’un seul

document

insert_many() - Insertion d’une liste de

documents

47
delete_one() - Suppression d’un
document
delete_many() - Suppression d’une
liste de documents
update_one() - Modification d’un
document

update_many() - Modification d’une

liste de documents

resultat = db.Etudiants.aggregate([
{"$group":{"_id":"$filiere.intitule",
"moyenne":{"$avg":"$moy1A"}}
}])
for i in resultat:
print(i["moyenne"],"moyenne de ",
i["_id"])

j. La sécurité des accès :

Pour créer un utilisateur sur une base de données, il faut spécifier :
• Le login
• Le mot de passe
• Et le (les) rôles à lui attribuer
Pour les rôles existent :
 dbAdmin : Administrateur de la base de données.
 dbOwner : Combine les éléments suivants : readWrite, dbAdmin userAdmin
 read : Lire les données sur toutes les collections.
 readWrite : les privilèges du rôle lecture , on a le droit d'écriture.
 userAdmin : créer et modifier les utilisateurs et les rôles sur la DB actuelle

Exemple :
use Examples
db.createUser( {
user: "UserAdmin",
pwd: "password" ,
"roles" : [{ "role" : "userAdmin",
"db" : "Examples" }]
})

o db.getUser(user) : Pour afficher les détails d’un user.

o db.dropUser(user) : Pour supprimer un user.
o db.auth(<login>,<motDePasse>) - db.auth("UserAdmin","password") : Pour
s’authentifier à la base avec le compte d’un utilisateur

48
k. Importation et exportations:
 Importer data base : l’importation peut être sous format JSON ou bien CSV
 mongoimport -d nomBaseDonnees -c nomDeLaCollection fichier.json
 mongoimport -d nomBaseDonnees -c nomDeLaCollection --type csv, --file fichier.csv

Exemple :
 mongoimport -d Examples -c Etudiants -type csv –file C:/data/Etudiants.csv
 mongoimport -d Examples -c Etudiants -o C:/data/ Etudiants.json

 Exporter data base : l’exportation peut être sous format JSON ou bien CSV
 mongoexport -d nomBaseDonnees -c nomDeLaCollection -o fichier.json
 mongoexport -d nomBaseDonnees -c nomDeLaCollection -f
champ_1,champ_2,champ_3 --csv -o fichier.csv

Exemple :
 mongoexport -d Examples -c Etudiants -o C:/data/etudiants.json
 mongoexport -d Examples -c Etudiants -f _id,nom,prenom,niveau,option --csv -o
C:/data/etudiants.csv

49
50