Qu’est-ce que SQL ?

SQL (structured query language) est un langage permettant de manipuler des bases de donnes relationnelles :

• Recherche d’enregistrements
• Insertion d’enregistrements
• Modification d’enregistrements
• Suppression d’enregistrements

Initialement créé par IBM, son succès en fait un standard dont l’évolution est maintenant sous le contrôle de l’Institut Américain de Normalisation.

Introduction et vocabulaire :

Dans un modèle relationnel, un fichier, tel qu’on le conçoit en informatique, en vu comme un tableau à 2 dimensions :

• Chaque ligne (tuple) du tableau représente un enregistrement du fichier
• Chaque colonne du tableau représente un champ du fichier

Un fichier est appelé une relation ou un table.
Toute relation (table) porte un nom.
Toute colonne porte un nom.
Les champs sont aussi appelés les attributs de la relation (table).
Une ligne est aussi appelée un tuple.
L’ensemble des valeurs que peut prendre un champ (colonne) s’appelle >un domaine.
Le nombre de colonnes (champs) d’une relation (table) est appelé degré de la relation.
Le nombre de lignes (tuples) d’une relation (table) est appelé cardinal de la relation.
La clé est un champ ou groupe de champs (colonnes) dont les valeurs identifient de façon univoque chaque ligne (tuple) de la table (relation).
Une clé composée d’un seul champ (colonne) est appelée clé simple.
Une clé composée de plusieurs champs (colonnes) est appelée clé composite.

A / La création d’une table :

Pour créer une table, il existe une commande CREATE TABLE.

Seront renseignés :

• Le nom des colonnes
• Leurs types
• Leurs contraintes de domaine
• Leurs contraintes d’intégrité

 

Exemple :

/*Création de la table*/
CREATE TABLE MyTableFournisseurs
(
/*Création des colonnes au format (NomColonne Type contrainte,)*/
ColumnCodeFournisseur char(5) not null,
ColumnFournisseur Varchar(255) not null,
ColumnAdresseFournisseur Varchar (255) not null,
CONSTRAINT PK_NomFnr PRIMARY KEY (ColumnFournisseur)
);
GO

/*Création de la table*/
CREATE TABLE MyTableProduits
(
/*Création des colonnes au format (NomColonne Type contrainte,)*/
ColumnCode Char(5) not null,
ColumnLibelle Char(55) not null,
ColumnPrix Money not null,
ColumnExemplaires int null,
ColumnFournisseur Varchar(255) not null,
CONSTRAINT PK_CodeProd PRIMARY KEY (ColumnCode),
CONSTRAINT FK_MyTableP_ref_MyTableF FOREIGN KEY(ColumnFournisseur)
REFERENCES MyTableFournisseurs(ColumnFournisseur)
ON DELETE CASCADE
);
GO

A-1 Les types de données :

Les types de données les plus courants sont :
Char, Varchar, Money, DateTime, SmallDateTime, Decimal, Numeric, int, SmallInt, BigInt …

Syntaxe: ColumnExemplaires int null,
Note : La longueur maximale du type se note entre parenthèse à coté du type comme ceci :

NomColonne Varchar(25) not null,

A-2 Les contraintes de domaine :

NOT NULL : La colonne ne peut pas contenir de valeurs NULL.
UNIQUE : Chaque ligne de la table doit avoir une valeur différente ou NULL pour cette (ou ces) colonne.
DEFAULT : Valeur par défaut.
Syntaxe : ColumnPrix Money NOT NULL

A-3 Les contraintes d’intégrité :

A-3a Les clés primaires:

 

Chaque ligne de la table doit avoir une valeur différente pour cette (ou ces) colonnes. Les valeurs NULL sont rejetées car c’est la clé de la table.

Syntaxe : PRIMARY KEY (NomColonne)
Remarque : La clé de la table peut être composée.

Exemple :

ADD CONSTRAINT NomPK PRIMARY KEY (colonneA, colonneB)

A-3 b Les clés étrangères :
Une clé étrangère est une colonne qui fait référence à une colonne clé d’une autre table.

Syntaxe : FOREIGN KEY (NomColonne) REFERENCES NomTable(colonne)

B / La suppression d’une table :
Pour supprimer une table, il existe une commande DROP TABLE.

Exemple :

/*Suppression de la table*/
DROP TABLE NomTable

 

Remarque: Lors de la suppression d’une table, il est indispensable de tenir compte des contraintes d’intégrité.

C / Renommer une table :
Pour renommer une table, il existe une commande RENAME.
(Note : Cette commande fonctionne aussi pour renommer une colonne avec une modification de table, ci-dessous).

Exemple :

/*Renommer la table*/
RENAME AncienNomTable TO NouveauNomTable

 

Remarque: Pour renommer une table, il est indispensable de tenir compte des contraintes d’intégrité.

D / Modification d’une table :
Pour modifier une table, il existe une commande ALTER TABLE.
Il existe deux types de modifications possibles :

• Gestion des colonnes
• Gestion des contraintes

D-1 La gestion des colonnes :

L’ajout ou la modification d’une colonne existante est possible. Il n’est pas possible de supprimer une colonne, mais une colonne inutilisée peut être mise à valeur NULL, auquel cas, elle n’occupe plus d’espace disque.

Pour supprimer réellement une colonne qui n’a pas de clé dans d’autres tables, il faudra donc :

• Créer une nouvelle table sans la colonne
• Détruire l’ancienne table
• Donner à la nouvelle table le nom de l’ancienne

D-1a Ajouter une colonne :
Pour ajouter une colonne à une table, il existe une commande ADD COLUMN.

Exemple :

/*Ajout d’une colonne à la table*/
ALTER TABLE NomTable
ADD COLUMN NomNouvelleColonne Char(10) not null

D-1b Supprimer une colonne :
Pour supprimer une colonne d’une table, il existe une commande DROP COLUMN.

Exemple :

/*Suppression d’une colonne de la table*/
ALTER TABLE NomTable
DROP COLUMN NomColonne

 

Remarque: La colonne ne sera pas supprimée mais toutes ses valeurs seront mises à NULL, il est indispensable de tenir compte des contraintes d’intégrité.

D-2 La gestion des contraintes :

L’ajout ou la suppression de contraintes sur une table est possible.

D-2a Ajout d’une contrainte :

Exemple :

/*Ajout d’une contrainte à la table*/
ALTER TABLE NomTable
(
ADD CONSTRAINT FK_MaCleEtrangere FOREIGN KEY (NomColonne)
REFERENCES MyTable (NomColonne)
)

D-2b Suppression d’une contrainte :

Exemple :

/*Suppression d’une contrainte de la table*/
ALTER TABLE NomTable
DROP CONSTRAINT FK_MaCleEtrangere

 

Remarque: Pour supprimer une contrainte, il est indispensable de tenir compte des contraintes d’intégrité. Lors de la suppression d’une clé étrangère, deux options sont disponibles :

ON DELETE NO ACTION sert à refuser la suppression
ON DELETE CASCADE sert à accepter la suppression

 

Exemple :

/*Création de la table*/
CREATE TABLE MyTableProduits
(
/*Création des colonnes */
ColumnCodeProd Char(5) not null,
ColumnLibelle Char(55) not null,
ColumnFournisseur Varchar(255) not null,

/*Creation des contraintes d’intégrité*/
CONSTRAINT PK_CodeProd PRIMARY KEY (ColumnCode),
/*Création de la clé étrangère avec en contrainte ON DELETE CASCADE*/
CONSTRAINT FK_MyTableP_ref_MyTableF FOREIGN KEY(ColumnFournisseur)
REFERENCES MyTableFournisseurs(ColumnFournisseur) ON DELETE CASCADE
)
GO

D-2c La contrainte CHECK:
CHECK est suivi d’une expression booléenne.

Les opérateurs booléens autorisés sont :
= > < NOT AND OR IN BETWEEN
Exemple :

/*Création de la table*/
CREATE TABLE MyTableA
(
/*Création des colonnes au format (NomColonne Type contrainte,)*/
Column1 int PRIMARY KEY,
Column2 Varchar(5) default 'G',
Column3 Varchar (255) not null,
/*La contrainte CHECK*/
CONSTRAINT CK_Column2 CHECK (Column2 = 'G' OR Column2 = 'H')
)
GO

E/ Les commande SQL :

Les commandes SQL servent à trier, ajouter, supprimer des informations dans les tables. La syntaxe SQL est simple et ne contient que peu de commande à mémoriser.

E-1 Les commandes les plus couramment utilisées :

E-1a La commande SELECT :

/*Sélection une colonne ou tout le contenu de la table*/
SELECT NomColonne FROM NomTable

Remarque: Pour sélectionner toutes les colonnes, le NomColonne sera remplacé par * .

E-1b La commande sans doublons :

/*La commande distinct permet de ne sortir qu'une fois le resultat même s'il en
est fait plusieurs fois référence dans la table*/
SELECT DISTINCT NomColonne FROM NomTable

E-1c Les commandes de restriction :

Les opérateurs utilisables sont : = > < >= <= <>

Il est possible de comparer :

• Deux colonnes entre-elles
• Une colonne à une constante
• Une colonne à une expression
• Une expression à une constante

 

WHERE

/*Sélection des données par condition «simple»*/
SELECT * FROM NomTable
WHERE ColonneType = '10'

 

AND/OR

/*Sélection des données par condition «complexe»*/
SELECT NomColonne FROM NomTable
WHERE (ColonneType = '10' AND ColonnePrix < '20')

SELECT * FROM NomTable
WHERE (ColonneType = '10' OR ColonneLibelle = 'crayon couleur')

 

BETWEEN

/*Sélection des valeurs de la colonne comprises entre 10 et 20*/
SELECT NomColonne FROM NomTable
WHERE NomColonne BETWEEN '10' AND '20'

 

IN

/*Sélection des données incluant les valeurs 1, 2 et 3*/
SELECT * FROM NomTable
WHERE NomColonne IN ('Valeur1', 'Valeur2', 'Valeur3')

 

LIKE

/*Sélection des données incluant la chaine %Chaine%*/
SELECT NomColonne FROM NomTable
WHERE NomColonne LIKE '%Outils%'

 

/*Sélection des données n'incluant pas la chaine %Chaine%*/
SELECT NomColonne FROM NomTable
WHERE NomColonne NOT LIKE '%Outils%'

 

/*Sélection des données commençant par la chaine Chaine%*/
SELECT NomColonne FROM NomTable
WHERE NomColonne LIKE 'A%'

 

/*Sélection des données se terminant par la chaine %Chaine*/
SELECT NomColonne FROM NomTable
WHERE NomColonne LIKE '%E'

 

E-1d Les valeurs nulles :

/*Sélection des données dont la colonne ‘NomColonne’ est nulle*/
SELECT NomColonne FROM NomTable
WHERE NomColonne IS NULL

E-1e Les fonctions prédéfinies:

Des fonctions de calcul :

• COUNT -> pour compter le nombre de résultats
• SUM -> pour la somme de l’expression
• AVG -> pour la moyenne d’un groupe (valeurs nulles ignorées)
• MIN -> pour la valeur minimale de l’expression
• MAX -> pour la valeur maximale de l’expression

Exemples :

SELECT COUNT(ColumnLibelle) AS 'Nombre de produits'
FROM MyTableProduits

Des fonctions diverses :

• INT (expression) -> partie entière de l’expession
• ABS (expression) -> valeur absolue de l’expression
• MOD (expr1, expr2) -> retourne le reste de « expr1 / expr2 »
• SUBSTRING(chaine, début, longueur) -> retourne une sous-chaine
• UPPER (chaine) -> retourne la chaine en majuscules
• YEAR(variable date/heure) -> retourne l’année
• MONTH(variable date/heure) -> retourne le mois
• DAY(variable date/heure) -> retourne le jour
• HOUR(variable date/heure) -> retourne l’heure
• MINUTE(variable date/heure) -> retourne les minutes
• SECONDE(variable date/heure) -> retourne les secondes

Exemples :

SELECT UPPER(ColumnLibelle) AS 'Article', ColumnPrix AS 'Prix'
FROM MyTableProduits

E-1f Trier la table:
Chaque nom de colonne peut être suivi de :

• ASC pour trier en ascendant (séquence par défaut)
• DESC pour trier en dégressif

 

/*Trier la table par ordre du nom de la colonne*/
SELECT * FROM MaTable
ORDER BY NomColonne

 

/*Trier la table par ordre de StockProduit décroissant, dont le
libelleProduit commence par B*/
SELECT LibelleProduit , StockProduit FROM TableProduit
WHERE LibelleProduit LIKE 'B%'
ORDER BY StockProduit DESC

E-1g Renommer ou donner un nom a une colonne sur une requête:

Le AS permet de donner un nom à une colonne par exemple.

/*Nombre de produit par catégorie (<5)*/
SELECT 'Inferieur a 5' AS 'Catégorie',
COUNT(ColumnLibelle) AS 'Nombre de produits'
FROM MyTableProduits
WHERE ColumnExemplaires < 5

 

Note :

• ‘Inferieur a 5’ AS ‘Catégorie’ est une création de colonne qui a pour valeur ‘Inferieur a 5’ et pour nom de colonne ‘Catégorie’

• COUNT(ColumnLibelle) AS ‘Nombre de produits’ est une colonne qui a pour valeur COUNT(ColumnLibelle) qui est le nombre de produits et pour nom de colonne ‘Nombre de produits’

E-1h L’opérateur d’union :

L’opérateur UNION permet de réunir dans un même tableau les résultats de plusieurs requêtes.

Les tables réunies doivent être homogènes : même nombre de colonnes et même type pour chaque colonne.

/*Nombre de produit par catégorie (<5 / 5 à 20 / >20)*/
SELECT 'Inferieur a 5' AS 'Catégorie',
COUNT(ColumnLibelle) AS 'Nombre de produits'
FROM MyTableProduits
WHERE ColumnExemplaires < 5
UNION
SELECT 'Compris entre 5 et 20', COUNT(ColumnLibelle)
FROM MyTableProduits
WHERE ColumnExemplaires BETWEEN 5 AND 20
UNION
SELECT 'Supperieur à 20', COUNT(ColumnLibelle)
FROM MyTableProduits
WHERE ColumnExemplaires > 20

 

E-1i Les requêtes de groupage :
Les groupages permettent d’obtenir des données sur des critères de notre choix.
Remarque :

• La liste qui suit le SELECT doit faire référence exclusivement à des colonnes de la table et / ou à des données statiques appliquées à des colonnes de la table
• La liste qui suit le GROUP BY doit citer toutes les colonnes critères listées dans la liste du SELECT.

/*Les produits qui ont moins de 5 exemplaires, groupés par
libelle, par ordre de Libelle (alphabétique)
SELECT ColumnLibelle FROM MyTableProduits
WHERE ColumnExemplaires < 5
GROUP BY ColumnLibelle ORDER BY ColumnLibelle

E-1j Les propriétés des groupes:

Le prédicat (ici : SUM(ColumnPrix) < 10) doit porter sur les propriétés du groupe.

Un des termes de chaque condition doit donc être une fonction statique(ici : SUM(ColumnPrix)).

 

/*Sélection des libellés des produits et des prix*/
SELECT ColumnLibelle AS 'Article', SUM(ColumnPrix) AS 'Prix'
FROM MyTableProduits
GROUP BY ColumnLibelle
HAVING SUM(ColumnPrix) < 10
ORDER BY ColumnLibelle