Initiation SQL: Creation et requettage de base

de données
Bienvenue à tous à cette masterclass sur l'initiation à SQL, un langage de requête essentiel dans
le monde passionnant des bases de données. Je suis ravi de partager avec vous les fondements
de SQL, qui joue un rôle crucial dans la gestion et l'exploitation efficace des données.

Quis Suis-je?
• Dr. Alla LO
• Specialiste en Intelligence Artificielle et en Business Intelligence
• CEO du Cabinet BICALPRO/AL Consulting
• Enseignant Associe a l'UNCHK, DIT, ESMT, EPF, ...

Pourquoi SQL ?
Les bases de données sont omniprésentes dans notre monde numérique, alimentant des
applications que nous utilisons au quotidien. SQL, ou Structured Query Language, sert de pont
entre nous et ces vastes réservoirs de données. Aujourd'hui, nous explorerons ensemble les
bases de SQL, en nous concentrant sur la création de bases de données et le requêtage pour
récupérer, manipuler et gérer ces données.

Objectif de la Masterclass :
L'objectif de cette session est de vous fournir une base solide pour comprendre et utiliser SQL.
Que vous soyez novice en la matière ou que vous cherchiez à consolider vos connaissances, cette
masterclass couvrira les concepts fondamentaux, de la création d'une base de données à
l'exécution de requêtes complexes.

À qui s'adresse cette Masterclass ?

Cette masterclass est conçue pour les débutants et ceux qui ont une connaissance de base de
SQL. Si vous êtes un professionnel cherchant à acquérir des compétences dans la gestion de
bases de données, ou simplement quelqu'un qui souhaite comprendre comment interagir avec
les données, vous êtes au bon endroit.

Structure de la Masterclass :
Nous allons suivre la progression logique suivante:

• I- Présentaion des bases de données Relationnelles

• II- Presentaion du langage SQL.
• II- Cas pratique pour mettre en oeuvre les concepts developpés dans les paries
precedentes.
• IV- Nous terminerons par une séance de question/reponses.
Interactivité :
Je vous encourage à poser des questions tout au long de la session. L'interactivité est la clé de
l'apprentissage, et je suis ici pour vous aider à chaque étape du processus.

Sans plus tarder, plongeons dans le monde fascinant de SQL. Prêts à créer et requêter des bases
de données ? Commençons !

I- Data Base (30 min)

I-1. Qu'est-ce qu'une donnée ?
Définition
Les données, dans le contexte informatique, font référence à des faits, mesures, observations ou
informations brutes qui sont collectées, stockées et traitées. Les données peuvent prendre
différentes formes, telles que des chiffres, des textes, des images, des fichiers, etc. Elles sont la
matière première à partir de laquelle l'information et la connaissance sont extraites.

Différents types de données!

• Les données peuvent être qualitatives ou quantitatives.
• Les données qualitatives - Sont des informations descriptives (elles décrivent
quelque chose).
• Les données quantitatives - Sont des informations numériques (nombres).
• Les données quantitatives peuvent être discrètes ou continues :
• Les données discrètes ne peuvent prendre que certaines valeurs (c'est-à-dire des
nombres entiers - 1, 2, 3), tandis que...
• Les données continues peuvent prendre n'importe quelle valeur (dans une plage).
• En résumé : Les données discrètes sont comptées, les données continues sont
mesurées.

I-2. qu'est-ce qu'une base de données ?

Une base de données est une collection d'informations organisée de manière à ce qu'elle puisse
être facilement consultée, gérée et mise à jour.

Les bases de données peuvent être électroniques comme SQL ou non électroniques comme un
annuaire téléphonique. Tant qu'il y a des informations stockées à un endroit, on peut le
considérer comme une base de données !
Les données sont organisées en lignes, colonnes et tables, et elles sont indexées pour faciliter la
recherche d'informations pertinentes.

Exemples d'utilisation de bases de données :

• Sites et applications dynamiques comme Facebook, Google, Apple, etc.

• Suivi d'articles, une bibliothèque, etc.

Certains métiers professionnels qui travaillent avec les bases de données

comprennent :
• Les développeurs web, les analystes de données et les scientifiques des données.

I-3 Qu'est-ce qu'une base de données relationnelle ?

• Une base de données relationnelle est un système de stockage et d'organisation de
données reposant sur le modèle relationnel, où l'information est structurée en tables.
• Chaque table représente une entité particulière, avec des enregistrements individuels
représentés par des lignes et des attributs spécifiques représentés par des colonnes.
• Les relations entre les tables sont établies à l'aide de clés, dont la clé primaire identifie
de manière unique chaque enregistrement, et la clé étrangère établit des liens entre les
tables.
• Ce modèle offre une gestion efficace des données, assurant la cohérence, la rapidité
d'accès et la flexibilité pour effectuer diverses opérations sur les informations stockées.
• Il est largement utilisé dans des systèmes de gestion de bases de données relationnelles,
facilitant le stockage, la recherche et la manipulation de données dans diverses
applications.

I-4. Modélisation de Base de Données Relationnelle

I-4-1. Tables
Définnition: Les tables sont des structures rectangulaires composées de lignes et de colonnes.

utilité: Elles servent à organiser et à stocker les données.

+------------------+
| Utilisateurs |
+------------------+
| user_id |
| nom_utilisateur |
| email |
+------------------+

I-4-2. Colonnes (Attributs)

Définnition: Chaque colonne d'une table représente un attribut spécifique (par exemple, le nom,
l'âge, etc.).

utilité: Les colonnes définissent le type d'information stockée dans une table.
+------------------+
| Utilisateurs |
+------------------+
| user_id |
| nom_utilisateur |
| email |
+------------------+

I-4-3. Lignes (Tuples)

Définnition: Chaque ligne dans une table représente un enregistrement spécifique.

Utilité: Les lignes contiennent les données réelles et sont souvent appelées tuples.

+------------------+
| Utilisateurs |
+------------------+
| user_id |
| nom_utilisateur |
| email |
+------------------+
| 1 |
| JohnDoe |
| [email protected] |
+------------------+

I-4-4. Clés Primaires

Définnition: Une clé primaire est une colonne ou un ensemble de colonnes qui identifie de
manière unique chaque enregistrement dans une table.

Utilité: Elle garantit l'unicité des enregistrements.

+------------------+
| Utilisateurs |
+------------------+
| PK user_id |
| nom_utilisateur |
| email |
+------------------+

I-4-5. Clés Étrangères

Définnition: Une clé étrangère est une colonne qui établit un lien entre deux tables.

Utilité: Elle crée une relation entre les tables, généralement basée sur la clé primaire d'une table
liée à la clé étrangère d'une autre table.
+---------------+ +--------------+
| Commandes | | Produits |
+---------------+ +--------------+
| PK commande_id| | PK produit_id|
| FK user_id | (Utilisateurs) | nom |
| FK produit_id | (Produits) | prix |
+---------------+ +--------------+

I-4-6. Relations
Définnition: Les relations décrivent comment les tables sont liées les unes aux autres.

Utilité: Elles permettent de comprendre comment récupérer des données de plusieurs tables.

+----------------+ +---------------+
| Utilisateurs | | Commandes |
+----------------+ +---------------+
| PK user_id | | PK commande_id|
| nom_utilisateur| | FK user_id |
| email | | date_commande |
+----------------+ +---------------+
| ^
| |
+--------------------------------+
Relation (1) → (N)

Dans ce schéma conceptuel :

• Utilisateurs a une clé primaire (PK user_id) qui est liée à la clé étrangère (FK
user_id) de la table Commandes.

I-4-7. Cardinalité des Relations

Définition: La cardinalité définit le nombre d'occurrences dans une relation entre tables.

Utilité: Elle indique si une relation est de un à un, un à plusieurs ou plusieurs à plusieurs.

• La relation entre les deux tables est représentée par la flèche indiquant qu'un utilisateur
peut avoir plusieurs commandes (relation 1 → N).
Utilisateurs (1) -> Commandes (N)

I-4-8. Normalisation
Définition : La normalisation est le processus d'organisation des données pour éviter la
redondance et garantir l'intégrité des données.

Utilité : Elle améliore la structure globale de la base de données.

Les trois premières formes normales (1NF, 2NF, 3NF) sont des étapes successives dans ce
processus.
 1. 1NF (Première Forme Normale) :
– Chaque colonne de la table doit contenir une valeur atomique, c'est-à-dire qu'elle
ne doit pas être divisible en parties plus petites.
– Toutes les valeurs de chaque colonne doivent être du même type de données.
2. 2NF (Deuxième Forme Normale) :
– La table doit être en 1NF.
– Toutes les colonnes non clés doivent dépendre entièrement de la clé primaire.
– Élimination des dépendances partielles, où certaines colonnes dépendent
seulement d'une partie de la clé primaire.
3. 3NF (Troisième Forme Normale) :
– La table doit être en 2NF.
– Élimination des dépendances transitives, où une colonne non clé dépend d'une
autre colonne non clé à travers une colonne intermédiaire (non clé).

Chacune de ces formes normales vise à améliorer la structure d'une base de données en
réduisant la redondance des données et en garantissant que chaque information est stockée de
manière logique et non redondante. Ces principes de normalisation sont cruciaux pour maintenir
la qualité des données et assurer une gestion efficace des bases de données relationnelles.

I-4-9. Modèle Entité-Relation (ER)

Définition : Le modèle ER est une approche de modélisation visuelle pour représenter la
structure d'une base de données.

Utilité : Il offre une vue graphique des entités et de leurs relations.

+---------------------+ +---------------------+
| Auteurs | | Livres |
+---------------------+ +---------------------+
| PK auteur_id | | PK livre_id |
| nom_auteur | | titre |
| nationalite | | annee_publication |
+---------------------+ | FK auteur_id |
+---------------------+
|
| (Relation)
|
+---------------------+
| EcritPar |
+---------------------+
| PK id_relation |
| FK livre_id |
| FK auteur_id |
+---------------------+

Dans ce schéma ER simplifié :

• Il y a deux entités principales : Auteurs et Livres.

 • Chaque entité a des attributs spécifiques, et la clé primaire est indiquée par "PK"
(Primary Key).
• Il existe une relation "EcritPar" qui lie les entités Livres et Auteurs. Cette relation est
représentée par une table intermédiaire qui a des clés étrangères (FK) vers les clés
primaires des entités liées.

I-4-10. Index
Définition : Un index est une structure de données qui améliore la vitesse de récupération des
données.

Utilité : Il accélère les opérations de recherche dans une table. Bien sûr, voici une représentation
simplifiée d'un index dans le contexte d'une table :

+---------------------+
| Utilisateurs |
+---------------------+
| PK user_id |
| nom |
| email |
| age |
+---------------------+

+---------------------+
| Index |
+---------------------+
| PK index_id |
| FK user_id |
| index_colonne |
+---------------------+

Dans cet exemple :

• Il y a une table principale appelée Utilisateurs avec des colonnes telles que user_id,
nom, email, et age.
• Il y a une table d'index associée. Cet index a une clé primaire (index_id) et une clé
étrangère (user_id) qui fait référence à la clé primaire de la table Utilisateurs.
• La colonne index_colonne est la colonne indexée. Cela pourrait être une colonne
spécifique de la table principale utilisée pour accélérer les recherches.

Cela représente un index qui améliore la vitesse de recherche des données dans la table
principale en utilisant une colonne spécifique. Vous pouvez avoir plusieurs index sur différentes
colonnes en fonction des besoins de recherche de votre application.

I-5. Types de données

Les types de données pour les colonnes des tables sont définis dans le schéma. La manière dont
vous développez votre schéma vous appartient !

Les types de données les plus courants sont :

 • INTEGER - entier 32 bits. Identique au type int en Python.
• BIGINT - entier 64 bits. Identique au type int en Python.
• FLOAT - Identique au type float en Python.
• BOOLEAN - Identique au type bool en Python.
• TEXT - Identique au type str en Python de longueur inconnue.
• VARCHAR - Identique au type str en Python de longueur fixe.
• DATE - Identique au type datetime.date en Python.
• TIME - Identique au type datetime.time en Python.
• TIMESTAMP - Identique au type datetime.datetime en Python.
• SERIAL - Entier auto-incrémenté (par exemple, 1, 2, 3 ...). Calculé automatiquement.
• NULL - permet de stocker des valeurs NULL. Identique au type None en Python.
• autres types.

Notes
Il est important d'avoir le type de données correct pour vos données. Cela garantit que le tri et
les calculs fonctionnent correctement.

II- SQL (40 min)

II-1. qu'est-ce que le SQL dans le monde informatique ??
Le SQL (Structured Query Language) est un des outils préférés du Data Analyst (et bientôt le tien
!).

SQL, ou Structured Query Language, est un langage de programmation qui fait aujourd’hui
référence dans l’utilisation des bases de données relationnelles.

• SQL est un langage de programmation :

1. De définition de données, ou Data Definition Language (DDL) : il permet de créer,
modifier ou supprimer des tables dans une base de données relationnelle,
2. De manipulation de données, ou Data Manipulation Language (DML) : il permet de
sélectionner, insérer, modifier ou supprimer des données dans une table d'une base de
données relationnelle,
3. De contrôle de données, ou Data Control Language (DCL) : il permet de définir des
permissions au niveau des utilisateurs d'une base de données)
• SQL et les SGBD
– Implémenté dans la plupart des SGBD
– Mais étendu différemment par chaque SGBD
– Exemple de SGBD:
• MySQL
• PostgreSQL
• Microsoft SQL
• SQLite
 • Oracle

II-2 A quoi sert le langage SQL ?

Avec SQL, il est possible de :

• Créer une base de données,

• Réaliser des tables dans une base de données,
• Interroger ou demander des informations à partir d'une base de données,
• Insérer des enregistrements dans une base de données,
• Mettre à jour ou modifier des enregistrements dans une base de données,
• Supprimer des enregistrements de la base de données,
• Définir les permissions ou le contrôle d'accès dans la base de données pour la sécurité
des données,
• Définir des vues pour éviter de taper des requêtes complexes fréquemment utilisées,

Remarque : la liste ne se termine pas ici ! Grâce à des requêtes SQL, tu peux effectuer de
nombreuses autres tâches liées à la base de données.

II-2. Bref tous d'horizon de SQL

Voici un tour d'horizon de SQL (Structured Query Language)

II-2-1. DDL (Data Definition Language) : Langage de Définition des Données

La syntaxe générale pour les commandes DDL (Data Definition Language) en SQL est la
suivante :

1. Créer une table (CREATE TABLE) :

CREATE TABLE nom_table (

colonne1 TYPE1 [contrainte1],
colonne2 TYPE2 [contrainte2],
...
PRIMARY KEY (colonne_principale),
FOREIGN KEY (colonne_reference) REFERENCES autre_table
(colonne_reference)
);

– Exemple :

CREATE TABLE Employés (

ID INT PRIMARY KEY,
Nom VARCHAR(50),
Département VARCHAR(50)
);

2. Modifier une table (ALTER TABLE) :

 ALTER TABLE nom_table
ADD COLUMN nouvelle_colonne TYPE [contrainte],
DROP COLUMN colonne_existante,
MODIFY COLUMN colonne_modifiée TYPE [nouveau_type];

– Exemple :

ALTER TABLE Employés

ADD COLUMN Salaire INT,
DROP COLUMN Téléphone,
MODIFY COLUMN Nom VARCHAR(100);

3. Supprimer une table (DROP TABLE) :

DROP TABLE nom_table;

– Exemple : DROP TABLE Employés;

4. Ajouter une clé étrangère (ALTER TABLE) :

ALTER TABLE table1

ADD FOREIGN KEY (colonne_reference) REFERENCES table2
(colonne_reference);

– Exemple :

ALTER TABLE Commandes

ADD FOREIGN KEY (ClientID) REFERENCES Clients (ID);

Ces commandes DDL vous permettent de définir, modifier et supprimer des structures de base
de données, notamment des tables et des contraintes. Les détails spécifiques peuvent varier en
fonction du système de gestion de base de données que vous utilisez (par exemple, MySQL,
PostgreSQL, SQL Server, etc.), mais la structure générale reste similaire.

II-2-2. DML (Data Manipulation Language) : Langage de Manipulation des Données

La syntaxe générale pour les commandes DML (Data Manipulation Language) en SQL, utilisées
pour interagir avec les données dans les tables, est la suivante :

1. INSERT INTO : Pour ajouter des données à une table.

INSERT INTO nom_table (colonne1, colonne2, ...)

VALUES (valeur1, valeur2, ...);

– Exemple :

INSERT INTO Employés (Nom, Département, Salaire)

VALUES ('Alice', 'RH', 50000);
 2. SELECT : Pour interroger des données dans une table.

SELECT colonne1, colonne2, ...

FROM nom_table
WHERE condition;

– Exemple :

SELECT Nom, Salaire

FROM Employés
WHERE Département = 'RH';

3. UPDATE : Pour mettre à jour des données existantes dans une table.

UPDATE nom_table
SET colonne1 = nouvelle_valeur1, colonne2 = nouvelle_valeur2, ...
WHERE condition;

– Exemple :

UPDATE Employés
SET Salaire = 55000
WHERE Nom = 'Alice';

4. DELETE : Pour supprimer des données d'une table.

DELETE FROM nom_table

WHERE condition;

– Exemple :

DELETE FROM Employés

WHERE Nom = 'Alice';

Ces commandes DML vous permettent de manipuler les données dans les tables en ajoutant,
sélectionnant, mettant à jour et supprimant des enregistrements. La syntaxe exacte peut varier
selon le système de gestion de base de données utilisé.

II-2-3. DCL (Data Control Language) : Langage de Contrôle des Données

La syntaxe générale pour les commandes DCL (Data Control Language) en SQL, utilisées pour
gérer les autorisations et les privilèges dans la base de données, est la suivante :

1. GRANT : Pour accorder des autorisations à un utilisateur ou à un rôle.

 GRANT autorisation
ON objet
TO utilisateur_ou_rôle;

– Exemple :

GRANT SELECT, INSERT

ON Employés
TO Utilisateur1;

2. REVOKE : Pour révoquer des autorisations précédemment accordées à un

utilisateur ou à un rôle.

REVOKE autorisation
ON objet
FROM utilisateur_ou_rôle;

– Exemple :

REVOKE INSERT
ON Employés
FROM Utilisateur1;

Ces commandes DCL (GRANT et REVOKE) sont utilisées pour contrôler l'accès aux objets de la
base de données, tels que les tables, les vues et d'autres objets, en accordant ou en révoquant
des autorisations spécifiques à des utilisateurs ou à des rôles. La syntaxe exacte peut varier selon
le système de gestion de base de données utilisé.

II-2-4. TCL (Transaction Control Language) : Langage de Contrôle des

Transactions
La syntaxe générale pour les commandes TCL (Transaction Control Language) en SQL, utilisées
pour gérer les transactions dans une base de données, est la suivante :

1. COMMIT : Pour valider les modifications apportées au sein d'une transaction.

COMMIT;

2. ROLLBACK : Pour annuler les modifications apportées au sein d'une transaction et

revenir à l'état précédent.

ROLLBACK;

3. SAVEPOINT : Pour définir un point de sauvegarde à l'intérieur d'une transaction,

permettant de revenir à ce point en cas de besoin.
 SAVEPOINT nom_du_savepoint;

4. ROLLBACK TO SAVEPOINT : Pour annuler les modifications et revenir à un point

de sauvegarde spécifique à l'intérieur d'une transaction.

ROLLBACK TO SAVEPOINT nom_du_savepoint;

5. SET TRANSACTION : Pour définir des caractéristiques de transaction, telles que

l'isolement et la durabilité.

SET TRANSACTION [ISOLATION LEVEL niveau_isolation] [READ WRITE |

READ ONLY];

Ces commandes TCL sont utilisées pour contrôler et gérer les transactions dans une base de
données relationnelle. Elles permettent de valider ou d'annuler les modifications effectuées au
sein d'une transaction, d'établir des points de sauvegarde, et de configurer des propriétés de
transaction. La syntaxe précise peut varier selon le système de gestion de base de données
utilisé.

II-2-5. Constraints (Contraintes)

Les contraintes sont des règles qui peuvent être appliquées aux données dans les tables. Elles
garantissent l'intégrité des données et peuvent inclure des contraintes telles que la clé primaire,
la clé étrangère, la contrainte d'unicité, etc.

La syntaxe générale pour définir des contraintes dans SQL dépend du type de contrainte que
vous souhaitez appliquer. Voici un aperçu des contraintes couramment utilisées et de leur
syntaxe générale :

1. Contrainte UNIQUE :

CREATE TABLE nom_table (

colonne1 type,
colonne2 type,
UNIQUE (colonne1)
);

– Exemple
CREATE TABLE livres (
ISBN VARCHAR(13) UNIQUE,
titre VARCHAR(255),
auteur VARCHAR(100)
);

2. Contrainte PRIMARY KEY :

 CREATE TABLE nom_table (
colonne1 type PRIMARY KEY,
colonne2 type
);

– Exemple
CREATE TABLE etudiants (
id_etudiant INT PRIMARY KEY,
nom VARCHAR(50),
prenom VARCHAR(50)
);

3. Contrainte FOREIGN KEY :

CREATE TABLE table_reference (

colonne_reference type PRIMARY KEY
);

CREATE TABLE table_principale (

colonne1 type,
colonne2 type,
cle_etrangere_colonne REFERENCES
table_reference(colonne_reference)
);

– Exemple
CREATE TABLE departements (
id_departement INT PRIMARY KEY,
nom_departement VARCHAR(100)
);

CREATE TABLE employes (

id_employee INT PRIMARY KEY,
nom VARCHAR(50),
id_departement INT,
FOREIGN KEY (id_departement) REFERENCES
departements(id_departement)
);

4. Contrainte CHECK :

CREATE TABLE nom_table (

colonne1 type,
colonne2 type,
CHECK (condition)
);
 – Exemple
CREATE TABLE employes (
id_employee INT PRIMARY KEY,
nom VARCHAR(50),
age INT CHECK (age >= 18)
);

5. Contrainte NOT NULL :

CREATE TABLE nom_table (

colonne1 type NOT NULL,
colonne2 type
);

– Exemple
CREATE TABLE clients (
id_client INT PRIMARY KEY,
nom VARCHAR(50) NOT NULL,
email VARCHAR(255)
);

6. Contrainte DEFAULT :

CREATE TABLE nom_table (

colonne1 type DEFAULT valeur_par_defaut,
colonne2 type
);

– Exemple
CREATE TABLE utilisateurs (
id_utilisateur INT PRIMARY KEY,
nom_utilisateur VARCHAR(50) DEFAULT 'Anonyme',
email VARCHAR(255)
);

7. Contrainte INDEX :

CREATE INDEX nom_index

ON nom_table (colonne1, colonne2);

– Exemple
CREATE INDEX idx_nom_client
ON clients (nom);
II-2-6. Transactions :
• Syntaxe Générale :

BEGIN TRANSACTION;

-- Opérations SQL ici --

COMMIT; -- Pour valider la transaction

-- ou ROLLBACK; -- Pour annuler la transaction

– Exemple :

BEGIN TRANSACTION;

UPDATE compte SET solde = solde - 100 WHERE utilisateur_id

= 123;
INSERT INTO historique_transactions (utilisateur_id,
montant, type) VALUES (123, 100, 'Retrait');

COMMIT;

II-2-7. Vues (Views) :

• Syntaxe Générale :

CREATE VIEW nom_vue AS

SELECT colonnes
FROM table
WHERE conditions;

– Exemple :

CREATE VIEW vue_clients_actifs AS

SELECT client_id, nom, prenom
FROM clients
WHERE statut = 'Actif';

II-2-8. Déclencheurs (Triggers) :

• Syntaxe Générale :

CREATE TRIGGER nom_declencheur

BEFORE | AFTER | INSTEAD OF event
ON table
FOR EACH ROW
BEGIN
-- Instructions SQL ici --
END;
 – Exemple :

CREATE TRIGGER declencheur_mise_a_jour

BEFORE UPDATE ON produits
FOR EACH ROW
BEGIN
SET NEW.derniere_mise_a_jour = NOW();
END;

II-2-9. Fonctions et Procédures Stockées :

• Syntaxe Générale (Procédure Stockée) :

CREATE PROCEDURE nom_procedure(parametres)

BEGIN
-- Instructions SQL ici --
END;

– Exemple (Procédure Stockée) :

CREATE PROCEDURE ajouter_client(IN nouveau_nom

VARCHAR(255), IN nouveau_prenom VARCHAR(255))
BEGIN
INSERT INTO clients (nom, prenom) VALUES (nouveau_nom,
nouveau_prenom);
END;

• Syntaxe Générale (Fonction) :

CREATE FUNCTION nom_fonction(parametres) RETURNS type

BEGIN
-- Instructions SQL ici --
END;

– Exemple (Fonction) :

CREATE FUNCTION calculer_taxes(prix DECIMAL) RETURNS

DECIMAL
BEGIN
RETURN prix * 0.1; -- 10% de taxes
END;

II-2-10. Optimisation des Requêtes :

• Syntaxe Générale :

CREATE INDEX nom_index ON table(colonne);

– Exemple :
 CREATE INDEX idx_nom ON clients(nom);

II-2-11. Sécurité :
• Syntaxe Générale :

GRANT privileges ON object TO utilisateur;

– Exemple :

GRANT SELECT, INSERT ON clients TO utilisateur1;

II-2-12. Jointures Avancées :

• Syntaxe Générale :

SELECT colonnes
FROM table1
JOIN table2 ON conditions;

– Exemple :

SELECT clients.nom, commandes.numero_commande

FROM clients
LEFT JOIN commandes ON clients.client_id =
commandes.client_id;

II-2-13. Fonctions d'Agrégation Avancées :

• Syntaxe Générale :

SELECT AGGREGATE_FUNCTION(colonne) AS resultat

FROM table
GROUP BY colonnes;

– Exemple :

SELECT category, STRING_AGG(product_name, ', ') AS products

FROM products
GROUP BY category;

II-2-14. Analytique SQL :

• Syntaxe Générale :

SELECT fonction_analytique() OVER (PARTITION BY partition_colonne

ORDER BY ordre_colonne) AS alias
FROM table;
 – Exemple :

SELECT ROW_NUMBER() OVER (ORDER BY salary DESC) AS

classement, employee_id, salary
FROM employees;

N'hésitez pas à adapter ces exemples en fonction de votre base de données et de vos besoins
spécifiques.