Télécharger pour lire hors ligne
![16
CREATE DATABASE [if not exists ]
MaBase
[CHARACTER SET utf8mb4]
[COLLATE utf8mb4_general_ci];
Utilisation d’une base de donné :
use test;
Supprimer une DataBase:
DROP DATABASE test
show create DATABASE test;
Afficher les moteurs de stockage :
show ENGINES;
Création d’une table :
CREATE TABLE [IF NOT
EXISTS] nom_table (
nomCol1 typeCol
[contraintes], nomCol2
typeCol [contraintes], ...
nomColN typeCol
[contraintes]
)[ENGINE=type_moteur]
[DEFAULT
CHARSET=jeu_de_caractères]
[COLLATE=nom_collation];
CREATE TABLE IF NOT EXISTS
Utilisateurs (
id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50) NOT NULL,
prenom VARCHAR(50) NOT NULL,
email VARCHAR(100) NOT NULL UNIQUE
)
ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLAT
E=utf8mb4_general_ci;
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 :
Une vue est une table virtuelle basée
sur le résultat d'une requête SQL.
Supprimer d’une vue
CREATE VIEW nom_de_vue AS
SELECT colonne1, colonne2, ...
FROM table
WHERE condition;
DROP VIEW nom_de_vue;
Création de table temporaire :
Une table temporaire est une table
qui n'existe que pendant la durée de
la session ou de la transaction.
Pour la Supprission
CREATE TEMPORARY TABLE nom_table_temporaire (
colonne1 type_donnée,
colonne2 type_donnée,
...
);
DROP TABLE nom_table_temporaire;](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-16-320.jpg)
![17
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
une valeur
nom_colonne type_donnee NOT NULL;
UNIQUE : Interdit deux même
valeurs pour une même colonne
nom_colonne type_donnee UNIQUE;
)
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) :
Clé étrangère, établit une relation avec
une autre table via sa clé primaire
CONSTRAINT nom_contrainte FOREIGN KEY
(nom_colonne) REFERENCES
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
condition sur une colonne
[CONSTRAINT [nom_contrainte]]
CHECK(expression) [[NOT] ENFORCED]
Example :
Cout DECIMAL(10,2 ) NOT NULL CHECK (cout>= 0),
DEFAULT : Définit une valeur par
défaut
nom_colonne type_donnee DEFAULT valeur_par_defaut;
Supprimer et modifier la table](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-17-320.jpg)
![18
Ajouter une ou plusieurs colonnes à
une table:
ALTER TABLE nom_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 à
une table:
ALTER TABLE nom_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
table:
ALTER TABLE nom_table CHANGE COLUMN
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](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-18-320.jpg)
![19
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](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-19-320.jpg)
![20
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 à
la table (n’est pas obligatoire)
SELECT * FROM Users as U;
Select * from Users U
[DISTINCT] : afficher le résultat sans
doublant
SELECT DISTINCT ville FROM Users
WHERE : définir la liste des
conditions
SELECT * FROM Users where age=12
GROUP BY : regrouper un ensemble
de ligne par valeurs de colonnes.
SELECT * FROM Users groupe by ville, age;
Having : la condition de
regroupement.
Select * FROM Users groupe by ville having age
>=20
ORDER BY : trie dans l’ordre croissant
ou décroissant, par défaut croissant
Select * FROM Users groupe by ville having age
>=20
Order by age ASC, ville DESC;
INNER JOIN … ON : Joint deux tables
en fonction d'une condition connue
sous le nom de prédicat de jointure
(Pas des valeurs null)
Exemple : sélectionne les noms des employés ainsi
que les noms des départements
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):
Cette jointure renvoie toutes les
lignes de la table de gauche, même
s'il n'y a pas de correspondance dans
la table de droite. Si aucune
correspondance n'est trouvée, les
valeurs de la table de droite seront
NULL.
Select e.nom, d.nom FROM employés e LEFT JOIN
départements d ON e.id = d.id;
Remarque : LEFT OUTER et RIGHT OUTER n’est pas
supporté par MYSQL
RIGHT JOIN (OU RIGHT OUTER JOIN):
Cette jointure renvoie toutes les
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.
Select e.nom, d.nom FROM employés e RIGHT JOIN
départements d ON e.id = d.id;
CROSS JOIN : Cette jointure renvoie
le produit cartésien des deux tables,
c'est-à-dire toutes les combinaisons
possibles de lignes entre les deux
tables. Sans ON
Exemple : Cette requête renverra toutes les
combinaisons possibles de noms d'employés et de
noms de projets, créant un tableau avec toutes les
associations possibles
SELECT e.nom, p.nom FROM employés e CROSS JOIN
projets p;](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-20-320.jpg)
![21
SELF JOIN ( table réflexive) : Cette
jointure renvoie le produit cartésien
des deux tables, c'est-à-dire toutes
les combinaisons possibles de lignes
entre les deux tables.
Exemple : Cette requête sélectionne le nom d'un
employé et le nom de son manager. (inner join , left
join , right join)
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
requête : select, insert, delete, update)
-- Préparation de la requête
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 :
Pendant la création de la table :
CREATE TABLE nom_table (
col1 TYPE,
….
INDEX (liste_colonne)
);
Après la création de la table :
CREATE [UNIQUE | FULLTEXT | SPATIAL]
INDEX nomIndex
[USING BTREE | HASH]
ON [nomBase.]nomTable (colonne1 [(taille1)]
[ASC | DESC], colonne2 [(taille2)] [ASC |
DESC], ...);
En modifiant la table :
ALTER TABLE nom_table ADD INDEX
nom_index (liste_colonne);
Exemple cas 1 :
CREATE TABLE clients (
id INT PRIMARY KEY,
nom VARCHAR(100),
ville VARCHAR(100),
INDEX (nom, ville)
);
Exemple cas 2 :
CREATE UNIQUE INDEX code_client_unique
ON ecole.clients (code_produit);
Exemple cas 3 :
ALTER TABLE clients ADD UNIQUE INDEX
unique_nom_index (nom);
Suppression d’un index :
DROP INDEX nom_index ON nom_table;
Exemple:
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
plusieurs requêtes SELECT en une seule, en
supprimant les doublons.
SELECT id, name FROM employees
UNION
SELECT id, name FROM managers;](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-21-320.jpg)
![23
SELECT * FROM clients WHERE EXISTS (SELECT *
FROM commandes WHERE clients.id =
commandes.client_id);
IN (sous_requete) : TRUE si l'opérande
est égal à un élément d'une liste
d'expressions. NOT IN dans le cas
contraire
Exemple : sélectionne les employés qui travaillent dans
les départements 'Informatique' ou 'Marketing'.
SELECT * FROM employés WHERE département IN
('Informatique', 'Marketing');
LIKE : TRUE si l'opérande correspond à un
modèle. Not Like dans le cas contraire.
Les Jocker : % plusieurs caractères.
_ un seul caractère.
Les regex : [ ], [^]
Exemple : sélectionne les clients dont le nom
commence par 'Jean'.
SELECT * FROM clients WHERE nom LIKE 'Jean%';
NOT : Inverse la valeur de tout autre
opérateur booléen.
Exemple : sélectionne les produits dont le prix n'est pas
inférieur à 50.
SELECT * FROM produits WHERE NOT prix < 50;
OR : TRUE si l'une ou l'autre expression
booléenne est TRUE.
Exemple : sélectionne les employés qui travaillent soit
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
éléments d'un jeu de comparaisons sont
TRUE
Exemple : sélectionne les produits dont le prix est
supérieur à certains des prix des produits de la
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
supérieure ou égale au nombre d'entrée
SELECT CEIL(4.3) AS valeur_ceil; 5
FLOOR() : Renvoie la plus grande valeur entière
non supérieure au nombre d'entrée.
SELECT FLOOR(4.9) AS valeur_floor; 4
MOD() : Renvoie le reste d'un nombre divisé par
un autre (modulo)
SELECT MOD(10, 3) AS reste; 1
ROUND() : Arrondit un nombre à un nombre
spécifié de places décimales
SELECT ROUND(3.456, 2) AS arrondi; 3.46
TRUNCATE() : Tronque un nombre à un nombre
spécifié de places décimales sans arrondir.
SELECT TRUNCATE(3.456, 2) AS tron;
SELECT TRUNCATE(3.456, 0) AS tron;
3.45
3](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-23-320.jpg)
![27
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';](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-27-320.jpg)
![28
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 :
DROP FUNCTION IF EXISTS nom_fonction;
CREATE FUNCTION nom_fonction (parameter)
RETURNS type_retour
BEGIN
-- Déclaration informative
DECLARE variable_example TYPE;
-- Instructions
SELECT 'Exécution des instructions ici';
RETURN type_retour;
END;
READS SQL DATA : lire les données
MODIFIES SQL DATA : modifie les données
CONTAINS SQL : elles ne lisent ni ne modifie
DELIMITER $$ : c’est comme point-virgule à la
fin d’une instruction il permet l’exécution des
instructions comme un seul bloc
Example:
DROP FUNCTION IF EXISTS nbrclient;
DELIMITER $$
CREATE FUNCTION nbrclient (v VARCHAR(255))
RETURNS INT
READS SQL DATA
BEGIN
DECLARE nombre INT;
-- Calcul du nombre de clients par ville
SET nombre = (SELECT COUNT(*)
FROM clients
WHERE adresse = v);
RETURN nombre;
END $$
DELIMITER ;
Appel de la fonction:
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
DELIMITER $$
Exemple avec IN:
DELIMITER $$](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-28-320.jpg)
![29
CREATE PROCEDURE nom_procedure (param1
INT, param2 VARCHAR(50))
BEGIN
-- Code SQL à exécuter
SELECT * FROM table WHERE colonne1 =
param1 AND colonne2 = param2;
END $$
DELIMITER ;
CREATE PROCEDURE ps_client(IN ville
VARCHAR(255))
BEGIN
SELECT * FROM clients
WHERE UPPER(adresse) = UPPER(ville);
END $$
DELIMITER ;
Appel de la PS:
CALL ps_client ('Rabat');
Exemple avec OUT :
DELIMITER //
CREATE PROCEDURE psClient(IN v
VARCHAR(255), OUT nbrCl INT)
BEGIN
SELECT COUNT(*) INTO nbrCl FROM clients
WHERE adresse = v;
END //
DELIMITER ;
Appel de la PS:
CALL psClient ('rabat', @total);
SELECT @total;
Exemple avec INOUT :
DELIMITER //
CREATE PROCEDURE SetCounter(INOUT counter
INT, IN inc INT)
BEGIN
SET counter = counter + inc;
END //
DELIMITER ;
Appel de la PS:
SET @counter = 0;
CALL SetCounter(@counter, 7);
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 condition THEN
instructions
END IF
IF-ELSE
IF condition THEN
instructions
ELSE
instructions
END IF
IF-ELSEIF-ELSE
IF condition 1 THEN
instructions
ELSEIF condition 2 THEN
instructions 2
ELSE
instructions 3
END IF
Case sans sélecteur
CASE
WHEN condition 1 THEN
instructions 1
WHEN condition 2 THEN
instructions 2
...
WHEN condition N THEN
instructions N
[ELSE instructions N+1]
END CASE
Case avec sélecteur
CASE variable_selector
WHEN expr1 THEN instructions1
WHEN expr2 THEN instructions2
...
WHEN exprN THEN instructionsN
[ELSE instructionsN+1]
END CASE](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-29-320.jpg)
![30
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
[label_debut:] LOOP
statement_list
END LOOP [label_fin]
WHILE
[label_debut:] WHILE condition DO
list_of_instructions
END WHILE [label_fin]
REPEAT
REPEAT
list_of_instructions
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:](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-30-320.jpg)
![31
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 ();](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-31-320.jpg)
![32
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
[ BEFORE | AFTER ] { INSERT | UPDATE |
DELETE }
ON nom_table
[ FOR EACH ROW ]
BEGIN
-- corps_declencheur
END;
CREATE TRIGGER nom_declencheur : Déclare un
nouveau déclencheur avec le nom spécifié.
[ BEFORE | AFTER ] : Indique si le déclencheur
s'exécute avant ou après l'opération spécifiée
(INSERT, UPDATE, DELETE).
{ INSERT | UPDATE | DELETE } : Spécifie
l'opération qui déclenche le déclencheur.
ON nom_table : Indique la table sur laquelle le
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, ' ',](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-32-320.jpg)
![33
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.).](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-33-320.jpg)
![35
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]
Condition instruction
[ELSE Instruction]
Ou bien
IF [NOT] EXISTS(requête select)
Instruction
[ELSE Instruction]
Example:
DECLARE @nbr int
SET @nbr = (SELECT COUNT(CltID) FROM Clients)
IF(@nbr <10)
PRINT ‘Plus de 10 Clients’
ELSE
PRINT ‘Moins de 10 Clients’
Syntaxe de la structure While
While [NOT] Condition instruction
Les instruction BREAK, CONTINUE
permettent respectivement
d’interrompre ou de continuer une
boucle.
DECLARE @i int
SET @i = 0
WHILE @i <10
BEGIN
PRINT ‘i=’+ CONVERT(varchar(2), @i)
SET @i=@i+1
END
L’étiquette GOTO : Syntaxe de CASE
'instruction GOTO permet de rediriger
l'exécution du flux de contrôle vers une
autre partie du script SQL à l'aide d'une
étiquette
DECLARE @i int
SET @i = 0
Debut:
PRINT 'Index=‘ +
CONVERT(varchar(2),@i)
SET @i = @i + 1
If (@i!=10)
goto debut
Existe deux utilisation de CASE en T-SQL :
- Le CASE simple. Equivalente de Switch dans C
- Le CASE de recherche.
DECLARE @NmbE int, @NmbS varchar(20)
SET @NmbE = 42
SELECT @NmbS = CASE @NmbE
WHEN 10 THEN ‘Dix’
WHEN 24 THEN ‘Vingt Quatre’
Else ‘aucun’
End
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
@parametre1 type,
@parametre2 type
AS Code Procédure
Créer une Procédure:
Create procedure GetProductId As Select
@prodid from product
Modifier une procédure:](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-35-320.jpg)
![37
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](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-37-320.jpg)
![40
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;](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-40-320.jpg)
![42
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
collection
db.nomCollection.insert( {
"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": "john@example.com",
"orders": [
{
"order_id": 1234,
"date": "2023-09-25",](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-42-320.jpg)
![43
"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": "john@example.com"
}
{
"_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"},](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-43-320.jpg)
![44
{"_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:
selection = {"note":{"$gte":10.00}}
db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0})
supérieur à : > $gt
supérieur ou égal à : >= $gte
inférieur à : < $lt
inférieur ou égal à : <= $lte
différent de : ≠ $ne
Appartient à la liste $in Exemple:
selection = {"option":{"$in":["A","B"]}}
db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0})
N’appartient pas à la liste $nin](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-44-320.jpg)
![45
ET Logique $and Exemple:
s = { "$or": [ { "note" : { "$gte" : 10 } }, {"option":"A"} ] }
db.Etudiants.find(s,{"nom":1,"prenom":1,"_id":0})
OU Logique $or
Not (OU Logique) $nor
Teste la présence ou non
d’un champ
$exists Exemple:
selection = { "option": {$exists : false }}
db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0})
Les Opérateurs
d’agrégation :
Ce calcul s’effectue avec la fonction aggregate() qui prend en paramètre
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 :
$match
Filtrer les documents de la collection suivant la sélection fournie à
l’opérateur $match
db. NomCollection.aggregate([{$match: {selection}}])
example:
db.Etudiants.aggregate([{$match: {"filiere.intitule" : "arabe" }}])
Opérateur d’agrégation :
$group
Permet d’effectuer des regroupements et faire des opérations
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}} ])](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-45-320.jpg)
![46
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()
for r in resultat[:2]:
print(r)
Pour afficher les données et faut parcourir le curseur](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-46-320.jpg)
![47
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
db.Etudiants.index_information().items():
print("index:" ,k, "valeur :",v,"n")
Retourne la liste des index de la collection
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](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-47-320.jpg)
![48
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 :
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
use Examples
db.createUser( {
user: "UserAdmin",
pwd: "password" ,
"roles" : [{ "role" : "userAdmin",
"db" : "Examples" }]
})](https://image.slidesharecdn.com/merisesqlplusdoc-241019155010-4af8b49a/85/Merise-SQL-SQL-Procedural-MySQL-TSQL-SQL-Server-PLSQL-Oracle-NOSQL-MongoDB-48-320.jpg)
Contenu connexe
Similaire à Merise - SQL - SQL Procedural (MySQL) - TSQL (SQL Server) - PLSQL (Oracle) - NOSQL (MongoDB)
Merise - SQL - SQL Procedural (MySQL) - TSQL (SQL Server) - PLSQL (Oracle) - NOSQL (MongoDB)
- 1. 1 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
- 2. 2 1. Définition d’unSystè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
- 3. 3 - 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 :
- 4. 4 6. Cahier decharge : 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.
- 5. 5 Règle degestion : 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 : 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 → code postal, Numéro client → ville, Numéro client → téléphone, Numéro client → mail 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 ac, ni bc 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é. Un attribut B dépend fonctionnellement de l’attribut A, noté AB si à une valeur de A correspond une et une seule valeur pour B . On dit que A déterminé B. Numéro client → (Nom client, prénom, adresse, code postal, ville, téléphone, mail) Source But
- 6. 6 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.
- 7. 7 Une entité ilpeut 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.
- 8. 8 Les seules cardinalitésadmises 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.
- 9. 9 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)).
- 10. 10 - Solution estla 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
- 11. 11 c. Conversion deMCD 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)
- 12. 12 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.
- 13. 13 15. Base desdonné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. Matiére(No_matiere) Professeur(No_prof) Classe(No_class) Assure(#No_class, #No_Prof,#No_matiere, codsalle)
- 14. 14 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" :
- 15. 15 (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 ;
- 16. 16 CREATE DATABASE [ifnot exists ] MaBase [CHARACTER SET utf8mb4] [COLLATE utf8mb4_general_ci]; Utilisation d’une base de donné : use test; Supprimer une DataBase: DROP DATABASE test show create DATABASE test; Afficher les moteurs de stockage : show ENGINES; Création d’une table : CREATE TABLE [IF NOT EXISTS] nom_table ( nomCol1 typeCol [contraintes], nomCol2 typeCol [contraintes], ... nomColN typeCol [contraintes] )[ENGINE=type_moteur] [DEFAULT CHARSET=jeu_de_caractères] [COLLATE=nom_collation]; CREATE TABLE IF NOT EXISTS Utilisateurs ( id INT AUTO_INCREMENT PRIMARY KEY, nom VARCHAR(50) NOT NULL, prenom VARCHAR(50) NOT NULL, email VARCHAR(100) NOT NULL UNIQUE ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLAT E=utf8mb4_general_ci; 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 : Une vue est une table virtuelle basée sur le résultat d'une requête SQL. Supprimer d’une vue CREATE VIEW nom_de_vue AS SELECT colonne1, colonne2, ... FROM table WHERE condition; DROP VIEW nom_de_vue; Création de table temporaire : Une table temporaire est une table qui n'existe que pendant la durée de la session ou de la transaction. Pour la Supprission CREATE TEMPORARY TABLE nom_table_temporaire ( colonne1 type_donnée, colonne2 type_donnée, ... ); DROP TABLE nom_table_temporaire;
- 17. 17 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 une valeur nom_colonne type_donnee NOT NULL; UNIQUE : Interdit deux même valeurs pour une même colonne nom_colonne type_donnee UNIQUE; ) 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) : Clé étrangère, établit une relation avec une autre table via sa clé primaire CONSTRAINT nom_contrainte FOREIGN KEY (nom_colonne) REFERENCES 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 condition sur une colonne [CONSTRAINT [nom_contrainte]] CHECK(expression) [[NOT] ENFORCED] Example : Cout DECIMAL(10,2 ) NOT NULL CHECK (cout>= 0), DEFAULT : Définit une valeur par défaut nom_colonne type_donnee DEFAULT valeur_par_defaut; Supprimer et modifier la table
- 18. 18 Ajouter une ouplusieurs colonnes à une table: ALTER TABLE nom_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 à une table: ALTER TABLE nom_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 table: ALTER TABLE nom_table CHANGE COLUMN 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
- 19. 19 ADD CONSTRAINT constraint_name FOREIGNKEY (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
- 20. 20 INNER JOIN TableAS 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 à la table (n’est pas obligatoire) SELECT * FROM Users as U; Select * from Users U [DISTINCT] : afficher le résultat sans doublant SELECT DISTINCT ville FROM Users WHERE : définir la liste des conditions SELECT * FROM Users where age=12 GROUP BY : regrouper un ensemble de ligne par valeurs de colonnes. SELECT * FROM Users groupe by ville, age; Having : la condition de regroupement. Select * FROM Users groupe by ville having age >=20 ORDER BY : trie dans l’ordre croissant ou décroissant, par défaut croissant Select * FROM Users groupe by ville having age >=20 Order by age ASC, ville DESC; INNER JOIN … ON : Joint deux tables en fonction d'une condition connue sous le nom de prédicat de jointure (Pas des valeurs null) Exemple : sélectionne les noms des employés ainsi que les noms des départements 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): Cette jointure renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite. Si aucune correspondance n'est trouvée, les valeurs de la table de droite seront NULL. Select e.nom, d.nom FROM employés e LEFT JOIN départements d ON e.id = d.id; Remarque : LEFT OUTER et RIGHT OUTER n’est pas supporté par MYSQL RIGHT JOIN (OU RIGHT OUTER JOIN): Cette jointure renvoie toutes les 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. Select e.nom, d.nom FROM employés e RIGHT JOIN départements d ON e.id = d.id; CROSS JOIN : Cette jointure renvoie le produit cartésien des deux tables, c'est-à-dire toutes les combinaisons possibles de lignes entre les deux tables. Sans ON Exemple : Cette requête renverra toutes les combinaisons possibles de noms d'employés et de noms de projets, créant un tableau avec toutes les associations possibles SELECT e.nom, p.nom FROM employés e CROSS JOIN projets p;
- 21. 21 SELF JOIN( table réflexive) : Cette jointure renvoie le produit cartésien des deux tables, c'est-à-dire toutes les combinaisons possibles de lignes entre les deux tables. Exemple : Cette requête sélectionne le nom d'un employé et le nom de son manager. (inner join , left join , right join) 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 requête : select, insert, delete, update) -- Préparation de la requête 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 : Pendant la création de la table : CREATE TABLE nom_table ( col1 TYPE, …. INDEX (liste_colonne) ); Après la création de la table : CREATE [UNIQUE | FULLTEXT | SPATIAL] INDEX nomIndex [USING BTREE | HASH] ON [nomBase.]nomTable (colonne1 [(taille1)] [ASC | DESC], colonne2 [(taille2)] [ASC | DESC], ...); En modifiant la table : ALTER TABLE nom_table ADD INDEX nom_index (liste_colonne); Exemple cas 1 : CREATE TABLE clients ( id INT PRIMARY KEY, nom VARCHAR(100), ville VARCHAR(100), INDEX (nom, ville) ); Exemple cas 2 : CREATE UNIQUE INDEX code_client_unique ON ecole.clients (code_produit); Exemple cas 3 : ALTER TABLE clients ADD UNIQUE INDEX unique_nom_index (nom); Suppression d’un index : DROP INDEX nom_index ON nom_table; Exemple: 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 plusieurs requêtes SELECT en une seule, en supprimant les doublons. SELECT id, name FROM employees UNION SELECT id, name FROM managers;
- 22. 22 UNION ALL (avecdoublons) SELECT id, name FROM employees UNION ALL SELECT id, name FROM managers; INTERSECT renvoie les valeurs communes (ou l'intersection) entre deux ensembles de résultats de requêtes SELECT SELECT column_name(s) FROM table1 INTERSECT SELECT column_name(s) FROM table2; MINUS permet de renvoyer les résultats de la première requête SELECT en excluant ceux qui apparaissent dans la deuxième requête SELECTE. SELECT column_name(s) FROM table1 MINUS 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 éléments d'un jeu de comparaisons sont TRUE. Exemple : sélectionne tous les produits dont le prix est supérieur à tous les prix des produits de la catégorie 'Livres'. SELECT * FROM produits WHERE prix > ALL (SELECT prix FROM produits WHERE catégorie = 'Livres'); AND : TRUE si les deux expressions booléennes sont TRUE. Exemple : Sélectionne les employés dont le salaire est 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 quel élément d'un jeu de comparaisons est TRUE. Exemple : Sélectionne les produits dont le prix est supérieur à n'importe quel prix des produits de la 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é dans une certaine plage. Exemple : Sélectionne les produits dont le prix est compris entre 100 et 500 SELECT * FROM produits WHERE prix BETWEEN 100 AND 500; EXISTS (sous_requete) : TRUE si une sous-requête contient des lignes. NOT EXISTS dans le cas contraire. Exemple : sélectionne les clients qui ont passé au moins une commande
- 23. 23 SELECT * FROMclients WHERE EXISTS (SELECT * FROM commandes WHERE clients.id = commandes.client_id); IN (sous_requete) : TRUE si l'opérande est égal à un élément d'une liste d'expressions. NOT IN dans le cas contraire Exemple : sélectionne les employés qui travaillent dans les départements 'Informatique' ou 'Marketing'. SELECT * FROM employés WHERE département IN ('Informatique', 'Marketing'); LIKE : TRUE si l'opérande correspond à un modèle. Not Like dans le cas contraire. Les Jocker : % plusieurs caractères. _ un seul caractère. Les regex : [ ], [^] Exemple : sélectionne les clients dont le nom commence par 'Jean'. SELECT * FROM clients WHERE nom LIKE 'Jean%'; NOT : Inverse la valeur de tout autre opérateur booléen. Exemple : sélectionne les produits dont le prix n'est pas inférieur à 50. SELECT * FROM produits WHERE NOT prix < 50; OR : TRUE si l'une ou l'autre expression booléenne est TRUE. Exemple : sélectionne les employés qui travaillent soit 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 éléments d'un jeu de comparaisons sont TRUE Exemple : sélectionne les produits dont le prix est supérieur à certains des prix des produits de la 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 supérieure ou égale au nombre d'entrée SELECT CEIL(4.3) AS valeur_ceil; 5 FLOOR() : Renvoie la plus grande valeur entière non supérieure au nombre d'entrée. SELECT FLOOR(4.9) AS valeur_floor; 4 MOD() : Renvoie le reste d'un nombre divisé par un autre (modulo) SELECT MOD(10, 3) AS reste; 1 ROUND() : Arrondit un nombre à un nombre spécifié de places décimales SELECT ROUND(3.456, 2) AS arrondi; 3.46 TRUNCATE() : Tronque un nombre à un nombre spécifié de places décimales sans arrondir. SELECT TRUNCATE(3.456, 2) AS tron; SELECT TRUNCATE(3.456, 0) AS tron; 3.45 3
- 24. 24 Les fonctions deCDC: Les fonctions de date: Fonction Explication Résultat CURDATE() : Renvoie la date actuelle SELECT CURDATE(); 2024-10-14 CONCAT() : Concaténer deux ou plusieurs chaînes en une seule chaîne. SELECT CONCAT('Hello', ' ', 'World') AS resultat; Hello World UPPER() : Convertir une chaîne en majuscule. SELECT UPPER('hello world') AS majuscule; HELLO WORLD LENGTH() : Obtenir la longueur d'une chaîne en octets. SELECT LENGTH('Bonjour') AS longueur; 7 LEFT() : Obtient un nombre spécifié de caractères les plus à gauche d'une chaîne. SELECT LEFT('Hello World', 5) AS partie_gauche; Hello LOWER() : Convertir une chaîne en minuscule. SELECT LOWER('HELLO WORLD') AS minuscule; hello world LTRIM() : Supprimer tous les espaces du début d'une chaîne. SELECT LTRIM(' Hello World') AS resultat; Hello World REPLACE() : Recherche et remplace une sous-chaîne dans une chaîne. SELECT REPLACE('Hello World', 'World', 'SQL') AS resultat; Hello SQL RIGHT() : Retourne un nombre spécifié de caractères les plus à droite d'une chaîne. SELECT RIGHT('Hello World', 5) AS partie_droite; World RTRIM() : Supprime tous les espaces de la fin d'une chaîne. SELECT RTRIM('Hello World ') AS resultat; Hello World SUBSTRING() : Extraire une sous- chaîne à partir d'une position avec une longueur spécifique. SELECT SUBSTRING('Hello World', 7, 5) AS sous_chaine; World TRIM() : Supprime les caractères indésirables d'une chaîne (espaces au début et à la fin) SELECT TRIM(' Hello World ') AS resultat; Hello World FORMAT() : Mettre en forme un nombre avec une locale spécifique, arrondi au nombre de décimales SELECT FORMAT(12345.678, 2) AS nombre_formate; 12,345.68 INSTR() : Renvoie la position de la première occurrence d'une sous- chaîne dans une chaîne. SELECT INSTR('Hello World', 'World') AS position; 7 FIND_IN_SET() : Rechercher une chaîne dans une liste de chaînes séparées par des virgules SELECT FIND_IN_SET('orange', 'apple,orange,banana') AS position; 2 SUBSTRING_INDEX() : Renvoie une sous-chaîne à partir d'une chaîne avant un nombre spécifié d'occurrences d'un délimiteur. SELECT SUBSTRING_INDEX ('apple,orange,banana', ',', 2) AS sous_chaine; apple,orange
- 25. 25 DATEDIFF() : Calculele nombre de jours entre deux dates SELECT DATEDIFF('2024-12-31', '2024-10- 14'); 78 DAY() : Obtient le jour du mois d'une date spécifiée SELECT DAY('2024-10-14'); 14 DATE_ADD() : Ajoute une valeur de temps à une date SELECT DATE_ADD('2024-10-14', INTERVAL 10 DAY); 2024-10-24 DATE_SUB() : Soustrait une valeur de temps d'une date SELECT DATE_SUB('2024-10-14', INTERVAL 7 DAY); 2024-10-07 DATE_FORMAT() : Formate une date en fonction d'un format spécifié SELECT DATE_FORMAT('2024-10-14', '%W, %M %d, %Y'); Monday, October 14, 2024 DAYNAME() : Renvoie le nom du jour de la semaine pour une date SELECT DAYNAME('2024-10-14'); Monday DAYOFWEEK() : Renvoie l'index du jour de la semaine (1 = Dimanche, 7 = Samedi) SELECT DAYOFWEEK('2024-10-14'); 2 (Lundi) EXTRACT() : Extrait une partie d'une date, par exemple l'année SELECT EXTRACT(YEAR FROM '2024-10- 14'); 2024 LAST_DAY() : Renvoie le dernier jour du mois pour une date donnée SELECT LAST_DAY('2024-10-14'); 2024-10-31 NOW() : Renvoie la date et l'heure actuelles SELECT NOW(); 2024-10-14 14:35:21 MONTH() : Renvoie le mois d'une date (en entier) SELECT MONTH('2024-10-14'); 10 STR_TO_DATE() : Convertit une chaîne de caractères en date selon un format SELECT STR_TO_DATE('14-10-2024', '%d- %m-%Y'); 2024-10-14 SYSDATE() : Renvoie la date et l'heure au moment où la requête est exécutée SELECT SYSDATE(); 2024-10-14 14:35:21 TIMEDIFF() : Calcule la différence entre deux heures SELECT TIMEDIFF('12:00:00', '09:30:00'); 02:30:00 TIMESTAMPDIFF() : Calcule la différence entre deux dates (en mois dans cet exemple) SELECT TIMESTAMPDIFF(MONTH, '2024- 01-01', '2024-10-14'); 9 WEEK() : Renvoie le numéro de la semaine dans l'année SELECT WEEK('2024-10-14'); 41 WEEKDAY() : Renvoie l'index du jour de la semaine (0 = Lundi, 6 = Dimanche) SELECT WEEKDAY('2024-10-14'); 0 (Lundi) YEAR() : Renvoie l'année d'une date spécifiée SELECT YEAR('2024-10-14'); 2024 Les fonctions de conversion: Fonction Explication Résultat TO_CHAR(nombre,format) : convertir un nombre en chaîne de caractères selon un format spécifique. SELECT TO_CHAR(12345.678, '99999.99') FROM dual; SELECT TO_CHAR(7, '00000') FROM dual; 12345.68 00007 TO_CHAR(date, format) : Cette fonction convertit une date en chaîne SELECT TO_CHAR(SYSDATE, 'DD/MM/YYYY') FROM dual; 14/10/2024
- 26. 26 de caractères selonle format de date spécifié SELECT TO_CHAR(SYSDATE, 'Month DD, YYYY') FROM dual; October 14, 2024 TO_DATE(chaîne, format) : La fonction TO_DATE convertit une chaîne de caractères en une date selon le format spécifié. SELECT TO_DATE('14-10-2024', 'DD-MM- YYYY') FROM dual; SELECT TO_DATE('2024 Oct 14', 'YYYY Mon DD') FROM dual; 2024-10-14 2024-10-14 TO_NUMBER(chaîne) : Cette fonction convertit une chaîne de caractères en une valeur numérique. SELECT TO_NUMBER('12345.67') FROM dual; SELECT TO_NUMBER(' 6789 ') FROM dual; 12345.67 6789 CAST() : convertir une expression d'un type de données à un autre SELECT CAST(12345 AS CHAR); SELECT CAST('2024-10-14' AS DATE); '12345' 2024-10-14 CONVERT() : convertir une valeur d'un type de données à un autre. SELECT CONVERT('2024-10-14', DATE); SELECT CONVERT(12345, CHAR); 2024-10-14 '12345' Les fonctions d’agrégation : Fonction Explication Résultat SUM() renvoie la somme des valeurs dans une colonne numérique SELECT SUM(salary) FROM employees; 500000 AVG() renvoie la moyenne des valeurs d'une colonne numérique SELECT AVG(salary) FROM employees; 50000 COUNT() renvoie le nombre de lignes qui correspondent à une condition donnée SELECT COUNT(*) FROM table_name; 10 MAX() renvoie la valeur maximale dans une colonne. SELECT MAX(salary) FROM employees; 120000 MIN() renvoie la valeur minimale dans une colonne. SELECT MIN(salary) FROM employees; 30000 c. LCD (MySQL) Créer un utilisateur : CREATE USER 'alice'@'localhost' IDENTIFIED BY 'motdepasse'; Modifier un utilisateur : ALTER USER 'alice'@'localhost' IDENTIFIED BY 'nouveaumotdepasse'; Renommer un utilisateur : Globale : *.* ; DB : dbtest.* Table : dbtest.Produits Colonne : SELECT (Num_Produit,Description Routine : GRANT EXECUTE ON PROCEDURE CPrix Proxy : GRANT PROXY ON root
- 27. 27 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';
- 28. 28 END; END; Les variables : DECLAREnomVar [,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 : DROP FUNCTION IF EXISTS nom_fonction; CREATE FUNCTION nom_fonction (parameter) RETURNS type_retour BEGIN -- Déclaration informative DECLARE variable_example TYPE; -- Instructions SELECT 'Exécution des instructions ici'; RETURN type_retour; END; READS SQL DATA : lire les données MODIFIES SQL DATA : modifie les données CONTAINS SQL : elles ne lisent ni ne modifie DELIMITER $$ : c’est comme point-virgule à la fin d’une instruction il permet l’exécution des instructions comme un seul bloc Example: DROP FUNCTION IF EXISTS nbrclient; DELIMITER $$ CREATE FUNCTION nbrclient (v VARCHAR(255)) RETURNS INT READS SQL DATA BEGIN DECLARE nombre INT; -- Calcul du nombre de clients par ville SET nombre = (SELECT COUNT(*) FROM clients WHERE adresse = v); RETURN nombre; END $$ DELIMITER ; Appel de la fonction: 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 DELIMITER $$ Exemple avec IN: DELIMITER $$
- 29. 29 CREATE PROCEDURE nom_procedure(param1 INT, param2 VARCHAR(50)) BEGIN -- Code SQL à exécuter SELECT * FROM table WHERE colonne1 = param1 AND colonne2 = param2; END $$ DELIMITER ; CREATE PROCEDURE ps_client(IN ville VARCHAR(255)) BEGIN SELECT * FROM clients WHERE UPPER(adresse) = UPPER(ville); END $$ DELIMITER ; Appel de la PS: CALL ps_client ('Rabat'); Exemple avec OUT : DELIMITER // CREATE PROCEDURE psClient(IN v VARCHAR(255), OUT nbrCl INT) BEGIN SELECT COUNT(*) INTO nbrCl FROM clients WHERE adresse = v; END // DELIMITER ; Appel de la PS: CALL psClient ('rabat', @total); SELECT @total; Exemple avec INOUT : DELIMITER // CREATE PROCEDURE SetCounter(INOUT counter INT, IN inc INT) BEGIN SET counter = counter + inc; END // DELIMITER ; Appel de la PS: SET @counter = 0; CALL SetCounter(@counter, 7); 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 condition THEN instructions END IF IF-ELSE IF condition THEN instructions ELSE instructions END IF IF-ELSEIF-ELSE IF condition 1 THEN instructions ELSEIF condition 2 THEN instructions 2 ELSE instructions 3 END IF Case sans sélecteur CASE WHEN condition 1 THEN instructions 1 WHEN condition 2 THEN instructions 2 ... WHEN condition N THEN instructions N [ELSE instructions N+1] END CASE Case avec sélecteur CASE variable_selector WHEN expr1 THEN instructions1 WHEN expr2 THEN instructions2 ... WHEN exprN THEN instructionsN [ELSE instructionsN+1] END CASE
- 30. 30 Structure de contrôleité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 [label_debut:] LOOP statement_list END LOOP [label_fin] WHILE [label_debut:] WHILE condition DO list_of_instructions END WHILE [label_fin] REPEAT REPEAT list_of_instructions 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:
- 31. 31 DECLARE nomException CONDITIONFOR 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 ();
- 32. 32 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 [ BEFORE | AFTER ] { INSERT | UPDATE | DELETE } ON nom_table [ FOR EACH ROW ] BEGIN -- corps_declencheur END; CREATE TRIGGER nom_declencheur : Déclare un nouveau déclencheur avec le nom spécifié. [ BEFORE | AFTER ] : Indique si le déclencheur s'exécute avant ou après l'opération spécifiée (INSERT, UPDATE, DELETE). { INSERT | UPDATE | DELETE } : Spécifie l'opération qui déclenche le déclencheur. ON nom_table : Indique la table sur laquelle le 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, ' ',
- 33. 33 NEW.prenom), NOW(), 'INSERT'); END; Listerles 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.).
- 34. 34 - Valider laTransaction : 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
- 35. 35 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] Condition instruction [ELSE Instruction] Ou bien IF [NOT] EXISTS(requête select) Instruction [ELSE Instruction] Example: DECLARE @nbr int SET @nbr = (SELECT COUNT(CltID) FROM Clients) IF(@nbr <10) PRINT ‘Plus de 10 Clients’ ELSE PRINT ‘Moins de 10 Clients’ Syntaxe de la structure While While [NOT] Condition instruction Les instruction BREAK, CONTINUE permettent respectivement d’interrompre ou de continuer une boucle. DECLARE @i int SET @i = 0 WHILE @i <10 BEGIN PRINT ‘i=’+ CONVERT(varchar(2), @i) SET @i=@i+1 END L’étiquette GOTO : Syntaxe de CASE 'instruction GOTO permet de rediriger l'exécution du flux de contrôle vers une autre partie du script SQL à l'aide d'une étiquette DECLARE @i int SET @i = 0 Debut: PRINT 'Index=‘ + CONVERT(varchar(2),@i) SET @i = @i + 1 If (@i!=10) goto debut Existe deux utilisation de CASE en T-SQL : - Le CASE simple. Equivalente de Switch dans C - Le CASE de recherche. DECLARE @NmbE int, @NmbS varchar(20) SET @NmbE = 42 SELECT @NmbS = CASE @NmbE WHEN 10 THEN ‘Dix’ WHEN 24 THEN ‘Vingt Quatre’ Else ‘aucun’ End 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 @parametre1 type, @parametre2 type AS Code Procédure Créer une Procédure: Create procedure GetProductId As Select @prodid from product Modifier une procédure:
- 36. 36 Appel d’une procédureStockée: avec exec ou execute Exec nomP Avec paramètre : Exec nomP @parametre1=val1, @parametre2=val2 Alter procedure GetProductId As Select @prodid, @prodName from product Appel d’une Procédure avec Paramètres exec getproductinfo @ prodid =10, @ProdName=‘Maria’ Ou bien 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 ,..., paraN typeN) returns type-resultat as begin ...... return valeur-resultante end example Create function nbr-stg (@id-class int) returns int as begin declare @nbr int select @nbr = count(*) from stagiaire where id-class = @id-class return @nbr end Appel de la fonction : select dbo.nbr-stg(3) create function Nom-fonction (para1 type1 ,..., paraN typeN) return @nom-table table (col1 type1, col2 type2,...) as begin .... return end example create function stg-M returns @stg table (id-stg int, nom varchar, prenom varchar) as begin insert into @stg select * from stagiaire where nom like 'M%' return end Appel de la fonction : 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.
- 37. 37 OPEN MyCursor • Lecturedu 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
- 38. 38 Exceptions Lever une exceptionRaiserror : 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.
- 39. 39 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;
- 40. 40 Curseurs : DECLARE CURSOR my_cursorIS 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;
- 41. 41 21. NoSQL avecMongoDB: 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 FilesMongoDBServer6.0bin 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
- 42. 42 d. Les notionsNoSQL : 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 collection db.nomCollection.insert( { "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": "john@example.com", "orders": [ { "order_id": 1234, "date": "2023-09-25",
- 43. 43 "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": "john@example.com" } { "_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"},
- 44. 44 {"_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: selection = {"note":{"$gte":10.00}} db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0}) supérieur à : > $gt supérieur ou égal à : >= $gte inférieur à : < $lt inférieur ou égal à : <= $lte différent de : ≠ $ne Appartient à la liste $in Exemple: selection = {"option":{"$in":["A","B"]}} db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0}) N’appartient pas à la liste $nin
- 45. 45 ET Logique $andExemple: s = { "$or": [ { "note" : { "$gte" : 10 } }, {"option":"A"} ] } db.Etudiants.find(s,{"nom":1,"prenom":1,"_id":0}) OU Logique $or Not (OU Logique) $nor Teste la présence ou non d’un champ $exists Exemple: selection = { "option": {$exists : false }} db.Etudiants.find(selection,{"nom":1,"prenom":1,"_id":0}) Les Opérateurs d’agrégation : Ce calcul s’effectue avec la fonction aggregate() qui prend en paramètre 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 : $match Filtrer les documents de la collection suivant la sélection fournie à l’opérateur $match db. NomCollection.aggregate([{$match: {selection}}]) example: db.Etudiants.aggregate([{$match: {"filiere.intitule" : "arabe" }}]) Opérateur d’agrégation : $group Permet d’effectuer des regroupements et faire des opérations 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}} ])
- 46. 46 i. Les requetésvia 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() for r in resultat[:2]: print(r) Pour afficher les données et faut parcourir le curseur
- 47. 47 selection={} selection["option"]="Mobile" resultat =db.Etudiants.find(selection) for iin 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 db.Etudiants.index_information().items(): print("index:" ,k, "valeur :",v,"n") Retourne la liste des index de la collection 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
- 48. 48 delete_one() - Suppressiond’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 : 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 use Examples db.createUser( { user: "UserAdmin", pwd: "password" , "roles" : [{ "role" : "userAdmin", "db" : "Examples" }] })
- 49. 49 k. Importation etexportations: 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
- 50.