*** CONVENTION ***

Les fonction doivent être en MAJUSCULE

Les noms de table en MINUSCULE

Les accents, caractère spéciaux et le pluriel sont interdit

Une option dans un champ est un attribut optionnel qui va modifier le comportement de ce champ.
Le type lui est obligatoire !

C’est une obligation de mettre un point-virgule( ; ) à la fin de chque instruction pour signaler à SQL qu’o

Pour signaler à SQL des noms de tables ou colonnes, utilisez des backticks ( 'name' ).

Pour signaler à SQL des Valeurs de type TEXT ou VARCHAR, utilisez des guillemets ('value').

Dès lors qu'il y a UPDATE, DELETE, ou bien DROP, soyez très vigilant, et vérifiez à deux fois votre comm

Pour importer une base de données dans Mysql, avec une ligne de commande, sous Windows, il faut :
1. Ouvrir l'invite de commande cmd
2. cd mon/chemin/
3. mysql -u root -p nom_de_la_base_de_donnees < nom_du_fichier.sql
4. mot de passe root
Ensuite il n'y plus qu'a verifier que la base de donnée du même nom, préalablement crée a été mise à

Pour extrait des informations spécifiques de votre BDD

Pour filtrer sur des données numériques on utilise le mot clé WHERE
Il s'utilise invariablement avec SELECT , UDPATE , DELETE.
Il supporte tous les opérateurs de comparaison comme = , <, <=, > ou >= .
Pour les données textuelles, on utilise LIKE
On peut utiliser le pourcentage (%) pour affiner la recherche.
On peut ordonner les résultats d’une requête SQL avec la commande ORDER BY.

Pour effectuer des opérations

Il est possible de compter le nombre de lignes d'une requête grâce à la fonction COUNT .
Pour identifier des doublons on peut utiliser la fonctionCOUNT combinée à la fonction DISTINCT .
On peut utiliser des alias grâce au mot clé AS pour renommer des variables ou des colonnes .
SQL propose une très grande variété de fonctions pour les nombres, pour les textes ou pour les dates.

Pour sauvegarder des requêtes

sauvegarder des requêtes complexes, longues ou utiliser très souvent.
SQL propose pour cela le concept de vue que l'on crée grâce à la commande CREATE VIEW
La commande peut être longue, alors n'hésitez pas à sauter des lignes, à mettre des parenthèses et de
Par convention on note ces vues avec "_vw" à la fin, pour les différencier des "vraies" tables.
Une fois créée une vue s'utilise comme une table "normale".

Les bases de données SQL sont dites de type “relationnel”. Cela sous-entend que leur force réside sur
On parle alors d’une relation 1 à plusieurs ou one-to-many, en anglais ; Lorsqu'on veut lier un objet d'
Ou de relation plusieurs à plusieurs ou many-to-many en anglais . Chaque objet d’une table pouvant ê
Aussi, cela se fait via la commande JOIN
Toutefois, par défaut, le SQL ne sait modéliser que des relations 1 à plusieurs.
Ainsi, pour povoir modeliser une relation plusieurs à plusieurs, il va falloir "tricher";
en utilisant des tables de liaison. Les tables de liaisons sont très importantes, parce qu'en faite sans ell
Car en réalité, une relation plusieurs à plusieurs, c’est une multitude de relations 1 à plusieurs.
Par convention, les tables de liaisons prennent le nom {table1}_{table2} , et servent à relier les tables
à l’id de l’objet de la table 2 correspondant.

Pour effectuer une jointure entre deux tables, on utilise les mots clés JOIN et ON .
On peut utiliser l'opérateur * ou on peut spécifier les colonnes que nous souhaitons sélectionner.
La requête fonctionne comme une requête normale. On peut rajouter des conditions avec WHERE , tr
Pour une relation one-to-many, la jointure se fait naturellement en spécifiant les deux colonnes à faire
Pour les relations many-to-many, il faut passer par une table d'association qui lie les deux tables entre
Pour faire une requête many-to-many, on fait donc une double jointure de notre table initiale à notre t

Vous savez que toute modification de la structure d’un objet s’effectue avec une commande ALTER TA
Pour ajouter un champ à un objet, il vous faut utiliser le mot clé ADD.
Pour supprimer un champ, le mot clé est DROP.
Pour modifier un champ, le mot clé est MODIFYpour en modifier la structure, CHANGE pour le renomm
Il faut être très vigilant quand on utilise la commandeALTER TABLE , et bien réfléchir aux conséquences
le comportement de ce champ.

nstruction pour signaler à SQL qu’on a terminé une instruction.

kticks ( 'name' ).

es guillemets ('value').

, et vérifiez à deux fois votre commande!

ommande, sous Windows, il faut : cd => change directory

u => user
p =>

, préalablement crée a été mise à jour.

e ORDER BY.

la fonction COUNT .
binée à la fonction DISTINCT .
ariables ou des colonnes .
pour les textes ou pour les dates.
mmande CREATE VIEW
es, à mettre des parenthèses et des indentations pour la rendre lisible.
ncier des "vraies" tables.

s-entend que leur force réside sur leur capacité à relier plusieurs types de données entre elles.
ais ; Lorsqu'on veut lier un objet d'une table à plusieurs objet d'une autre table
haque objet d’une table pouvant être relié à plusieurs objets de l’autre table, et vice versa.

alloir "tricher";
ortantes, parce qu'en faite sans elles pas de de relation many-to many.
e de relations 1 à plusieurs.
ble2} , et servent à relier les tables 1 et 2 qui y sont stockées, en sauvegardant l’id d’un objet de la table 1,

s JOIN et ON .
nous souhaitons sélectionner.
er des conditions avec WHERE , trier avec ORDER BY ou créer des alias avec AS .
spécifiant les deux colonnes à faire correspondre.
ciation qui lie les deux tables entre elles.
ure de notre table initiale à notre table de liaison, puis de notre table de liaison à notre table cible.

ue avec une commande ALTER TABLE.

tructure, CHANGE pour le renommer.

et bien réfléchir aux conséquences des modifications qui vont être effectuées.
t de la table 1,
 *** MEMO FONCTIONS SQ
SQL
CREATE DATABASE

SHOW DATABASES

USE
SHOW tables

CREATE TABLE

SHOW COLUMNS FROM table_name

INSERT INTO `table_name`

SELECT * FROM table_name

SELECT `colonne_name`, `...`, FROM

table_name;
UPDATE `table_name` SET
`colonne_name` = 'value_replaced'
WHERE `id` = 'id_n°';

DELETE FROM `table_name` WHERE `id`

= 'id_n°';

DROP DATABASE

DROP TABLE
WHERE

LIKE

ORDER BY
COUNT

DISTINCT

AS

• AVG
• SUM
• MAX
• MIN

CREATE VIEW
JOIN

JOIN
ALTER TABLE

RENAME TABLE
 *** MEMO FONCTIONS SQL ***
Opération
Crée une nouvelle base de données

Afficher la liste des bases de données

Choisir une base de données ou une table

Afficher les tables de la base de données choisi antérieurement

Crée une nouvelle table dans la base de données choisi

Afficher le schéma de la table indiqué

1. On indique en SQL qu’on souhaite ajouter un objet avec INSERT INTO.

2. On écrit ensuite le nom de la table dans laquelle on souhaite ajouter

l’objet, ici “b2b”.

3. On écrit ensuite entre parenthèses la liste des colonnes que l’on va

ajouter, ainsi que leur ordre.

4. On ajoute le mot clé VALUES qui indique qu’on va ensuite déclarer les
valeurs que l’on souhaite ajouter.

5. On écrit la liste des valeurs de l’objet qu’on souhaite ajouter, dans le

même ordre que les colonnes citées en 3.

Récupérer la données de toutes les colonnes de la table indiquée ;

SELECT(Récupérer la donnée)
*(Toutes
les colonnes de cette table) FROM table_name(Depuis la table
"table_name")
De la même manière qu’on précisait les colonnes que l’on souhaitait ajouter
avec INSERT, on peut préciser celles que l’on veut que l’application lise avec
SELECT.

Pour cela, il suffit de mentionner les noms de colonnes que l’on souhaite
récupérer après le mot clé SELECT
UPDATE table

Signifie à SQL que vous souhaitez mettre à jour de la donnée dans votre
BDD. Vous indiquez aussi la table dans laquelle se trouve(nt) le ou les objets
que vous souhaitez modifier.

SET colonne = valeur

Sert à indiquer à SQL quelles sont la ou les colonnes à modifier, et quelles

sont la ou les valeurs qu’elles doivent désormais prendre.

WHERE colonne = valeur

C’est ce qu’on appelle un filtre. Sert à restreindre la commande en cours à

un ou des objets répondant à des conditions précises. Ici, on va mettre à
jour uniquement l’objet dont l’id est ...

DELETE FROM table_name

Signifie à SQL que vous souhaitez suprimer de la donnée dans votre BDD.
Vous indiquez aussi la table dans laquelle se trouve(nt) le ou les objets que
vous souhaitez suprimer.

WHERE colonne = valeur

C’est ce qu’on appelle un filtre. Sert à restreindre la commande en cours à

un ou des objets répondant à des conditions précises. Ici, on va mettre à
jour uniquement l’objet dont l’id est ...

Supprimer une base de données

Supprimer une table

WHERE fonctionne avec un principe de comparaison pour indiquer que vous
ne vouliez uniquement que l’objet répondant au critère de comparaison ;

On peut utiliser tous les opérateurs classiques, tels que :

- Supérieur à ( > )

- Inférieur à ( < )

- Supérieur ou égal à (>=)

- Et inférieur ou égal à (<=)

On peut l’utiliser avec SELECT, UPDATE ou DELETE pour n’afficher, mettre

à jour ou supprimer qu’un objet spécifique, et non tous les objets de votre
table !

NB : La limite de WHERE est que la comparaison ne peut s’effectuer que

sur des données chiffrées.

LIKE est un mot clé pour effectuer des comparaisons sur du texte ;

Il permet de sélectionner les objets dont le texte d’une colonne répond à un

modèle spécifique. C’est en fait lui-même un opérateur, car il s’ajoute au
sein d’une commande WHERE.

Le caractère % va permettre de faire correspondre des schémas

spécifiques, on parle parfois de pattern, dans les données textuelles
%[Link] - - - - - > Texte se terminant par “[Link]“
[Link]% - - - - - > Texte commençant par “[Link]“
%[Link]% - - - -> Texte contenant “[Link]“ au début ou à la fin

Ce mot clé permet d’ordonner une colonne par ordre croissant (ascending
en anglais, d’où le mot clé SQL ASC), ou décroissant (descending en anglais,
soit le mot clé DESC).

SELECT *  Récupère toutes les données

FROM “aliment“  Dans la table “aliment“
ORDER BY calories ASC  Par ordre croissant de calories
DESC  Par ordre décroissant de calories
On utilise COUNT Pour savoir combien d’objets répondent à un critère (ou
une requête SQL) donné,
Appliqué à n’importe quelle commande SQL de type SELECT, il donnera le
nombre d’objets récupérés plutôt que leur valeur.
Pour savoir s'il y a des données en double, ou plutôt des doublons, Il
faudrait compter le nombre de produits qui sont distincts, c'est à dire qui
ont un nom différent.
Et bien c'est possible grâce au mot clé DISTINCT.

Grace au mot clé DISTINCT on peut compter le nombre d'objets étant

différents et ainsi identifier s'il existe des doublons dans un champ.

En SQL on peut utiliser le mot clé AS afin de donner des noms "artificiels" à
nos variables ou à nos colonnes.

AVG : nous donne la moyenne de la colonne sur la sélection ;

SUM : nous donne la somme de la colonne sur la sélection ;

MAX : nous donne le maximum de la colonne sur la sélection ;

MIN : nous donne le minimum de la colonne sur la sélection. Pour

avoir un resultat arrondi ou sous forme de nombre entier, on peut utilisé
ROUND en plus.

MySQL a un système de “vues” qui permet de créer des tables temporaires

à partir d’une commande SQL.
Permet de “sauvegarder” une commande SQL pour ne plus avoir à la
réeffectuer à chaque fois !
Permet expliquer à MySQL comment joindre deux tables selon un
identifiant qu’elles ont en commun.
RELATION ONE_TO_MANY

Permet expliquer à MySQL comment joindre deux tables selon un

identifiant qu’elles ont en commun.
RELATION MANY_TO_MANY
Il s’agit de la modification de la structure de la BDD en elle-même ;
Que ce soit pour l’ajout (ADD), la modification (MODIFY), la suppression
(DROP) ou pour renommer (CHANGE) un champs.

Modifier le nom d'une table

TIONS SQL ***
Syntaxe Exemple
CREATE DATABASE nom de la base de
CREATE DATABE client;
données;

SHOW DATABASES; SHOW DATABASES;

USE nom de la table; USE client;

SHOW tables; SHOW tables;

CREATE TABLE table_name ( CREATE TABLE utilisateur (

id INTEGER NOT NULL AUTO_INCREMENT id INTEGER NOT NULL AUTO_INCREMENT
PRIMARY KEY, PRIMARY KEY,
colonne 2_name TYPE(INT, VARCHAR, ...), nom VARCHAR(100),
colonne 3_name TYPE(INT, VARCHAR, ...), prenom VARCHAR(100),
colonne 4_name TYPE(INT, VARCHAR, ...) email VARCHAR(255) NOT NULL UNIQUE
); );

SHOW COLUMNS FROM nom de la table SHOW COLUMNS FROM b2b;

INSERT INTO `nom de la table` (`name of

INSERT INTO `b2b` (`raison sociale`,`telephone`
colonne 1`,`name of colonne 2` `name of
`email`)
colonne 3`)
VALUES ('ETS TRAORE', '27 22 22 22 22',
VALUES ('data of colonne 1', 'data of
'contact.ets_traore@[Link]');
colonne 2', 'data of colonne 3');

SELECT * FROM table_name; SELECT * FROM b2b;

SELECT `colonne_name`, `...`, FROM SELECT `raison sociale`,`telephone` `email`

table_name; FROM b2b;
DROP DATABASE database_name; DROP DATABASE client;

DROP TABLE table_name; DROP TABLE b2b;

SELECT * FROM table_name WHERE nom =
SELECT * FROM aliment WHERE nom = "poire";
"objet_name";

SELECT * FROM table_name WHERE SELECT * FROM utilisateur WHERE email LIKE
colonne_name LIKE "%filtre"; "%[Link]";

SELECT * FROM aliment ORDER BY calories SELECT * FROM aliment ORDER BY calories
ASC; ASC;

Ou Ou

SELECT * FROM aliment WHERE calories < SELECT * FROM aliment WHERE calories < 90
90 ORDER BY calories DESC; ORDER BY calories DESC;
 Quel est le nombre d’utilisateurs avec une
adresse Gmail dans la base ?
 SELECT COUNT(*)
FROM utilisateur
WHERE email LIKE "%[Link]";

Quel est le nombre d’utilisateurs avec une

adresse Gmail dans la colonne
“colonne_name“ ?
 SELECT COUNT(email)
FROM utilisateur
WHERE email LIKE "%[Link]";

Quel est le nombre d’utilisateurs distinct avec

une adresse Gmail dans la colonne
“colonne_name“ ?
 SELECT COUNT(DISTINCT nom)
FROM aliment
WHERE nom LIKE "%pomme%";

SELECT COUNT(DISTINCT colonne_name) SELECT COUNT(DISTINCT nom)

FROM table_name FROM aliment
WHERE colonne_name LIKE "%crictère%"; WHERE nom LIKE "%pomme%";

SELECT COUNT(DISTINCT colonne_name) SELECT COUNT(DISTINCT nom) AS "produits

AS "nom_artificiel" différents contenant le mot pomme"
FROM table_name FROM aliment
WHERE colonne_name LIKE "%crictère%"; WHERE nom LIKE "%pomme%";

SELECT MAX(colonne_name) AS SELECT MAX(sucre) AS "taux de sucre

"nom_artificiel" maximum"
FROM table_name; FROM aliment;

SELECT AVG(colonne_name) AS SELECT AVG(calories) AS "calories moyennes

"nom_artificiel" des aliments > 30g"
FROM table_name FROM aliment
WHERE critère; WHERE calories > 30;

SELECT ROUND(AVG(colonne_name)) AS SELECT ROUND(AVG(calories)) AS "calories

"nom_artificiel" moyennes des aliments > 30g"
FROM table_name FROM aliment
WHERE crictère; WHERE calories > 30;

CREATE VIEW utilisateurs_gmail_vw AS

( SELECT *
FROM utilisateur
WHERE email LIKE "%[Link]"
);
 Nous avons demandé à MySQL de sélectionner
tous les utilisateurs grâce à SELECT * FROM
• Nous demandons à MySQL de
`utilisateur`.
sélectionner tous les objets de la table 1
grâce à SELECT * FROM `table 1_name`.
Au résultat de cette commande nous avons
• Au résultat de cette commande nous
joint la table langue grâce à
joignons la table 2 grâce à
JOIN `table 2_name` .
JOIN `langue` .
• Mais pour pouvoir faire cette jointure, il
faut préciser à MySQL la correspondance
Mais pour pouvoir faire cette jointure, il faut
entre la table 2 et la table 1 . Ici, cette
préciser à MySQL la correspondance entre la
correspondance est effectuée via la clé
table langue et la table utilisateur . Ici, cette
table 2_id pour la table 1 et id pour la
correspondance est effectuée via la clé
table 2 . Ce la se fait grâce à ON `table
langue_id pour la table utilisateur et id pour
1_name`.`table 1_id` = `table 2`.`id` .
la table langue . Ce la se fait grâce à ON
`utilisateur`.`langue_id` = `langue`.`id` .

• Nous avons demandé à MySQL de

sélectionner tous les objets de la table 1 Nous avons demandé à MySQL de sélectionner
avec SELECT * FROM table 1_name tous les utilisateurs avec SELECT * FROM
utilisateur
Auxquels nous voulons joindre la table de
liaison table 1_table 2 avec JOIN table Auxquels nous voulons joindre la table
1.name_table [Link] utilisateur_aliment avec JOIN
utilisateur_aliment
En précisant à MySQL de les relier en
considérant que l’id de des objets de la table En précisant à MySQL de les relier en
1 est stocké en tant que table 1.name_id considérant que l’id de l’utilisateur est stocké
dans la table de liaison table 1.name_table en tant que utilisateur_id dans la table
[Link] avec ON (table 1.name_id = table utilisateur_aliment ON ([Link] =
1.name_table 2.name_id) utilisateur_aliment.utilisateur_id)

À ce JOIN , on veut à nouveau lier de la À ce JOIN , on veut à nouveau lier de la

donnée de la table 2, soit un nouveau JOIN donnée de la table aliment, soit un nouveau
avec JOIN table 2 JOIN avec JOIN aliment

Pour ce faire, on précise à MySQL que l’id de Pour ce faire, on précise à MySQL que l’id de
la table 2 est stocké dans table l’aliment est stocké dans utilisateur_aliment en
1.name_table 2.name_id avec ON (table tant que aliment_id avec ON ([Link] =
2_name.id = table 1.name_table utilisateur_aliment.aliment_id)
[Link] 2.name_id)
ALTER TABLE table_name ADD new
colonne_name TYPE(INT,VARCHAR, …) ;
ALTER TABLE aliment ADD vitamines_c FLOAT;
ALTER TABLE table_name DROP
colonne_name ; ALTER TABLE aliment DROP bio;

ALTER TABLE table_name MODIFY ALTER TABLE aliment MODIFY calories FLOAT;
colonne_name TYPE(INT,VARCHAR,…) ;
ALTER TABLE aliment CHANGE sucre sucres
ALTER TABLE table_name CHANGE previous FLOAT;
colonne_name new_name_of_colonne
TYPE(INT,VARCHAR,…) ;

RENAME TABLE ancien_nom TO

RENAME TABLE utilisateurs TO clients;
nouveau_nom;