Collège polytechnique d'Arbaminch

Modèle TTLM pourUtilisation du langage de requête structuré avancé

Basé sur
Norme Professionnelle Éthiopienne (NPE)

Utiliser le langage de requête structuré avancé

TITRE DU PROGRAMME EFTP : Administration des bases de données Niveau IV

MODULE TITLE:Utiliser le langage de requête structuré avancé

CODE DE MODULE :ICT DBA4 05 0411

NOMINAL DURATION:130hrs
MODULE DESCRIPTION:This unit covers the skills, knowledge and attitudes required to
utiliser le langage de requête structuré avancé (SQL) pour définir, créer et manipuler
structures de base de données et données associées dans une base de données relationnelle.

LEARNING OUTCOMES:

À la fin du module, l'apprenant sera capable de :

1. Écrire une requête SQL AVANCÉE pour récupérer et trier des données

2. Écrire des instructions SQL AVANCÉES qui utilisent des fonctions

Écrivez des requêtes SQL AVANCÉES qui utilisent des agrégations et des filtrages

Utilisation du langage de requête structuré avancé

CONTENU DU MODULE :
. Revue des commandes SQL de base
oSQL Avancé
oSQL Haut
oSQL Comme
Jokers oSQL
oSQL Dans
oSQL Entre
Alias oSQL
Jointures SQL
Jointure interne oSQL
Jointure gauche SQL complète
Jointure à droite oSQL
union oSQL
Sélectionner dans oSQL
Fonctions SQL
Aperçu des fonctions SQL
Commandes de tri
. ORDER BY
. REGROUPER PAR…
Fonctions SQL spéciales
. Fonctions mathématiques
. Fonctions de chaîne
. Fonctions de date
. Fonctions agrégées

Utilisation du langage de requête structuré avancé

 SQL Avancé

Clause TOP SQL

La clause TOP
La clause TOP est utilisée pour spécifier le nombre d'enregistrements à retourner.

La clause TOP peut être très utile sur de grandes tables avec des milliers d'enregistrements.
Le retour d'un grand nombre d'enregistrements peut avoir un impact sur la performance.

Note : Tous les systèmes de base de données ne prennent pas en charge la clause TOP.

Syntaxe SQL Server

SÉLECTIONNER TOP nombre|pourcentage nom_de_la_colonne(s)

DE nom_de_table

Exemple SQL TOP

La table "Personnes" :

P_Id LastName Prénom Adresse City

1 Hansen Bonjour Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

4 Nilsen Tom Vingvn 23 Stavanger

Maintenant, nous voulons sélectionner uniquement les deux premiers enregistrements dans le tableau ci-dessus.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER TOP 2 * DE Persons

Utiliser le langage de requête structuré avancé

Le jeu de résultats apparaîtra comme ceci :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

Exemple de PERCENT SQL

La table des "Personnes" :

P_Id LastName Prénom Adresse Ville

Timothée
1 Hansen Ola Sandnes
10

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

4 Nilsen Tom Vingvn 23 Stavanger

Maintenant, nous voulons sélectionner seulement 50 % des enregistrements dans le tableau ci-dessus.

Nous utilisons la déclaration SELECT suivante :

Sélectionner les 50 POUR CENT supérieurs * DE Persons

Le jeu de résultats ressemblera à ceci :

P_Id LastName FirstName Address Ville

1 Hansen Salut Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

Utiliser le Langage de Requête Structuré Avancé

SQL Comme

Opérateur LIKE SQL

L'opérateur LIKE est utilisé dans une clause WHERE pour rechercher un modèle spécifié dans
une colonne.

L'opérateur LIKE

L'opérateur LIKE est utilisé pour rechercher un motif spécifié dans une colonne.

Syntaxe SQL LIKE

SÉLECTIONNER le nom_de_colonne(s)

DE nom_table

OÙ column_name LIKE motif

Exemple d'opérateur LIKE

La table des "Personnes" :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Nous voulons maintenant sélectionner les personnes vivant dans une ville qui commence par "s".
table ci-dessus.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Personnes

OÙ Ville LIKE 's%'

Le signe "%" peut être utilisé pour définir des jokers (lettres manquantes dans le modèle) des deux côtés.
avant et après le motif.
Utiliser le langage de requête structuré avancé
L'ensemble des résultats ressemblera à ceci :

P_IdLastName FirstName Adresse Ville

1 Hansen Salut Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Ensuite, nous voulons sélectionner les personnes vivant dans une ville qui se termine par un "s" de la
"Persons" table.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DES Personnes

OÙ Ville LIKE '%s'

Le jeu de résultats ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

Timoteivn
1 Hansen Bonjour Sandnes
10

2 Svendson Tove Borgvn 23 Sandnes

Ensuite, nous voulons sélectionner les personnes vivant dans une ville contenant le motif "tav".
de la table "Personnes".

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Personnes

OÙ Ville LIKE '%tav%'

Le jeu de résultats ressemblera à ceci :

P_Id LastName FirstName Adresse City

Utilisation du langage de requête structuré avancé
 3 Pettersen Kari Storgt 20 Stavanger

Il est également possible de sélectionner les personnes vivant dans une ville qui ne contient PAS le
le motif "tav" de la table "Persons", en utilisant le mot-clé NOT.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Persons

OÙ la ville NE RESSEMBLE PAS à '%tav%'

L'ensemble des résultats ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

Timothée
1 Hansen Ola Sandnes
10

2 Svendson Tove Borgvn 23 Sandnes

Jokers SQL
Les caractères génériques SQL peuvent être utilisés lors de la recherche de données dans une base de données.

Jokers SQL
Les caractères génériques SQL peuvent remplacer un ou plusieurs caractères lors de la recherche de données
dans une base de données.

Les caractères génériques SQL doivent être utilisés avec l'opérateur SQL LIKE.

Avec SQL, les caractères de substitution suivants peuvent être utilisés :

Description
Caractère générique

% Un substitut pour zéro ou plusieurs caractères

Utilisation du langage de requête structuré avancé
 _ Un substitut pour exactement un caractère

[charlist] Tout caractère unique dans charlist

Tout caractère unique qui n'est pas dans la liste de caractères

or

[!charlist]

Exemples de caractères génériques SQL

Nous avons le tableau "Personnes" suivant :

P_Id LastName Prénom Adresse Ville

1 Hansen Bonjour Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Utiliser le joker %

Nous voulons maintenant sélectionner les personnes vivant dans une ville qui commence par "sa".
table des "Personnes".

Nous utilisons la déclaration SELECT suivante :

SELECT * FROM Persons

OÙ la Ville COMME 'sa%'

Le jeu de résultats ressemblera à ceci :

P_Id NomDeFamille FirstName Adresse Ville

Utilisation du langage de requête structuré avancé
 1 Hansen Salut Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

Ensuite, nous voulons sélectionner les personnes vivant dans une ville qui contient le motif "nes".
de la table "Persons".

Nous utilisons la requête SELECT suivante :

SÉLECTIONNER * DE Persons

OÙ Ville LIKE '%nes%'

L'ensemble de résultats ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

Utiliser le caractère générique _

Maintenant, nous voulons sélectionner les personnes dont le prénom commence par n'importe quel
personnage, suivi de "la" de la table "Persons".

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Personnes

OÙ FirstName COMME '_la'

L'ensemble des résultats ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timoteivn 10 Sandnes

Utiliser le langage de requête structuré avancé

Ensuite, nous voulons sélectionner les personnes dont le nom de famille commence par "S", suivi
par n'importe quel caractère, suivi de "fin", suivi de n'importe quel caractère, suivi de "sur"
de la table "Personnes".

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * À PARTIR DE Personnes

OÙ LastName LIKE 'S_end_on'

L'ensemble des résultats ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

2 Svendson Tove Borgvn 23 Sandnes

Utiliser le caractère générique [charlist]

Maintenant, nous voulons sélectionner les personnes dont le nom de famille commence par "b" ou "s" ou
"p" de la table "Persons".

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Personnes

OÙ LastName LIKE '[bsp]%'

Le jeu de résultats ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Ensuite, nous voulons sélectionner les personnes dont le nom de famille ne commence pas par "b" ou
"s" ou "p" de la table "Persons".

Utilisation du Langage de Requête Structuré Avancé

 Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Personnes

WHERE LastName LIKE '[!bsp]%'

Le résultat ressemblera à ceci :

P_Id LastName FirstName Adresse Ville

1 Hansen Salut Timoteivn 10 Sandnes

Opérateur IN SQL

L'opérateur IN

L'opérateur IN vous permet de spécifier plusieurs valeurs dans une clause WHERE.

Syntaxe SQL IN

SÉLECTIONNER le nom_de_colonne(s)

DE nom_de_table

OÙ nom_de_colonne DANS (valeur1,valeur2,...)

Exemple de l'opérateur IN

La table des "Personnes" :

P_Id LastName FirstName Adresse Ville

1 Hansen Ola Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Utiliser le langage de requête structuré avancé

 Maintenant, nous voulons sélectionner les personnes dont le nom de famille est égal à "Hansen" ou
Pettersen

Nous utilisons la déclaration SELECT suivante :

SELECT * FROM Persons

OÙ LastName IN ('Hansen','Pettersen')

Le jeu de résultats ressemblera à ceci :

P_Id LastName FirstName Adresse City

1 Hansen Bonjour Timoteivn 10 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

4.5. Opérateurs SQL BETWEEN

L'opérateur BETWEEN est utilisé dans une clause WHERE pour sélectionner une plage de données.
entre deux valeurs.

L'opérateur BETWEEN

L'opérateur BETWEEN sélectionne une plage de données entre deux valeurs. Les valeurs
can be numbers, text, or dates.

Syntaxe SQL BETWEEN

SÉLECTIONNER le nom_de_colonne(s)

DE nom_de_table

OÙ nom_de_colonne

ENTRE value1 ET value2

Exemple d'opérateur BETWEEN

Utilisation de SQL avancé
The "Persons" table:

P_Id LastName FirstName Address Ville

1 Hansen Bonjour Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Nous voulons maintenant sélectionner les personnes dont le nom de famille est alphabétiquement entre
"Hansen" et "Pettersen" de la table ci-dessus.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER * DE Personnes

WHERE LastName

ENTRE 'Hansen' ET 'Pettersen'

Le jeu de résultats ressemblera à ceci :

P_Id LastName Prénom Adresse Ville

Timothée
1 Hansen Salut Sandnes
10

Remarque : L'opérateur BETWEEN est traité différemment dans différentes bases de données.

Dans certaines bases de données, les personnes portant le nom de famille « Hansen » ou « Pettersen » vont
ne pas être répertorié,

Exemple 2

To display the persons outside the range in the previous example, use NOT
ENTRE :

SELECT * FROM Persons

OÙ NomDeFamille

Utilisation de SQL avancé

 PAS ENTRE 'Hansen' ET 'Pettersen'

Le jeu de résultats ressemblera à ceci :

P_Id LastName FirstName Address Ville

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Alias SQL

Avec SQL, un nom d'alias peut être donné à une table ou à une colonne.

Alias SQL
Vous pouvez donner un autre nom à une table ou une colonne en utilisant un alias. Cela peut être un
bonne chose à faire si vous avez des noms de table ou des noms de colonnes très longs ou complexes.

Un nom d'alias peut être n'importe quoi, mais généralement il est court.

Syntaxe des alias SQL pour les tables

SÉLECTIONNER le nom_de_colonne(s)

DE table_name

AS alias_name

Syntaxe des alias SQL pour les colonnes

SÉLECTIONNER nom_de_colonne COMME alias_de_nom

DE nom_table

Exemple d'alias

Utiliser le langage de requête structuré avancé

 Supposons que nous ayons une table appelée "Personnes" et une autre table appelée
"Commandes_Produits". Nous donnerons les alias de table de "p" et "po" respectivement.

Nous voulons maintenant répertorier toutes les commandes dont "Ola Hansen" est responsable.

Nous utilisons la déclaration SELECT suivante :

SELECT po.OrderID, p.LastName, p.FirstName

DE Persons COMME p,

Commandes_Produits EN po

WHERE p.LastName='Hansen'

OÙ p.FirstName='Ola'

La même instruction SELECT sans alias :

SÉLECTIONNER Product_Orders.OrderID, Persons.LastName

Persons.FirstName

DE Personnes,

Product_Orders

OÙ Persons.LastName='Hansen'

OÙ Persons.FirstName='Ola'

Comme vous le verrez dans les deux instructions SELECT ci-dessus, les alias peuvent rendre les requêtes
plus facile à écrire et à lire.

Jointures SQL

Les jointures SQL sont utilisées pour interroger des données provenant de deux tables ou plus, sur la base d'un

relation entre certaines colonnes dans ces tables.

SQL JOIN
Le mot clé JOIN est utilisé dans une instruction SQL pour interroger des données provenant de deux ou plusieurs

tables, basées sur une relation entre certaines colonnes de ces tables.

Les tables d'une base de données sont souvent liées entre elles par des clés.

Utiliser le langage de requête structuré avancé

Une clé primaire est une colonne (ou une combinaison de colonnes) avec une valeur unique pour
chaque ligne. Chaque valeur de clé primaire doit être unique au sein de la table. Le but
est de lier les données ensemble, à travers les tables, sans répéter toutes les données dans chaque
table.

Regardez le tableau "Personnes" :

P_Id LastName Prénom Adresse Ville

1 Hansen Bonjour Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Notez que la colonne "P_Id" est la clé primaire dans la table "Persons". Cela signifie
de sorte que deux lignes ne peuvent avoir le même P_Id. Le P_Id distingue deux personnes
même s'ils ont le même nom.

Utiliser le langage de requête structuré avancé

 Ensuite, nous avons la table "Commandes" :

O_Id OrderNo P_Id

1 77895 3

2 44678 3

3 22456 1

4 24562 1

5 34764 15

Notez que la colonne "O_Id" est la clé primaire dans la table "Orders" et que la
"P_Id" fait référence aux personnes dans la table "Persons" sans utiliser leurs
noms.

Remarquez que la relation entre les deux tables ci-dessus est la colonne "P_Id".

Différents JOINs SQL

Avant de continuer avec des exemples, nous allons énumérer les types de JOIN que vous pouvez utiliser,
et les différences entre eux.

JOIN: Return rows when there is at least one match in both tables

LEFT JOIN : Retournez toutes les lignes de la table de gauche, même s'il n'y a pas
correspondances dans la table de droite

JOINTURE À DROITE : Retourne toutes les lignes de la table de droite, même s'il n'y a pas
correspondances dans la table de gauche

JOIN COMPLET : Retourner les lignes lorsqu'il y a une correspondance dans l'une des tables

Mot-clé SQL INNER JOIN

Mot-clé SQL INNER JOIN

Le mot-clé INNER JOIN retourne des lignes lorsqu'il y a au moins une correspondance dans les deux.
tables.
Utilisation du langage de requête structuré avancé
Syntaxe SQL INNER JOIN

SELECT nom_de_colonne(s)

DE table_name1

JOIN interne table_name2

SUR table_name1.column_name=table_name2.column_name

PS : INNER JOIN est la même chose que JOIN.

Exemple de SQL INNER JOIN

La table des "Personnes" :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

La table "Commandes" :

O_Id OrderNo P_Id

1 77895 3

2 44678 3

3 22456 1

4 24562 1

5 34764 15

Nous voulons maintenant lister toutes les personnes ayant des commandes.

Nous utilisons la déclaration SELECT suivante :

Utilisation du langage de requête structuré avancé

 SELECT Personnes.NomDeFamille, Personnes.Prénom, Commandes.NuméroDeCommande

DE Personnes

JOIN INTERNE Commandes

ON Persons.P_Id=Orders.P_Id

ORDRE PAR Persons.LastName

Le jeu de résultats ressemblera à ceci :

LastName FirstName OrderNo

Hansen Bonjour 22456

Hansen Salut 24562

Pettersen Kari 77895

Pettersen Kari 44678

Le mot-clé INNER JOIN retourne des lignes lorsqu'il y a au moins une correspondance dans les deux.
tables. S'il y a des lignes dans "Persons" qui n'ont pas de correspondances dans "Orders", celles-ci
les lignes ne seront PAS listées.

Mot-clé SQL LEFT JOIN

Mot-clé SQL LEFT JOIN

Le mot-clé LEFT JOIN retourne toutes les lignes de la table de gauche (table_name1), même
s'il n'y a pas de correspondances dans la table de droite (table_name2).

Syntaxe SQL LEFT JOIN

SELECT nom_de_colonne(s)

DE table_name1
JOINTURE GAUCHE table_name2
Utilisation du langage de requête structuré avancé
 SUR table_name1.column_name=table_name2.column_name

PS : Dans certaines bases de données, LEFT JOIN est appelé LEFT OUTER JOIN.

Exemple de SQL LEFT JOIN

La table "Personnes" :

P_Id LastName FirstName Address City

Timothée
1 Hansen Bonjour Sandnes
10

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

La table "Commandes" :

O_Id OrderNo P_Id

1 77895 3

2 44678 3

3 22456 1

4 24562 1

5 34764 15

Nous voulons maintenant lister toutes les personnes et leurs commandes - le cas échéant, à partir des tables.
au-dessus.

Nous utilisons la déclaration SELECT suivante :

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo

DE Personnes
JOIN GAUCHE Commandes

Utilisation du langage de requête structuré avancé

 SUR Persons.P_Id=Orders.P_Id

ORDONNER PAR Persons.LastName

The result-set will look like this:

LastName FirstName OrderNo

Hansen Bonjour 22456

Hansen Bonjour 24562

Pettersen Kari 77895

Pettersen Kari 44678

Svendson Tove

Le mot-clé LEFT JOIN renvoie toutes les lignes de la table de gauche (Personnes), même si
il n'y a pas de correspondances dans la table de droite (Commandes).

Mot-clé SQL RIGHT JOIN

Mot-clé SQL RIGHT JOIN

Le mot-clé RIGHT JOIN renvoie toutes les lignes de la table de droite (table_name2),
même s'il n'y a pas de correspondances dans la table de gauche (table_name1).

Syntaxe de la jointure à droite SQL

SÉLECTIONNER le nom_de_colonne(s)

DE table_name1

JOINTURE DROITE table_name2

SUR table_name1.column_name=table_name2.column_name

PS : Dans certaines bases de données, le RIGHT JOIN est appelé RIGHT OUTER JOIN.

Exemple de JOIN DROIT SQL

La table "Personnes"

Utilisation du langage de requête structuré avancé

 P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

Le
3 Pettersen Kari Storgt 20 Stavanger

"Orders" table:

O_Id OrderNo P_Id

1 77895 3

2 44678 3

3 22456 1

4 24562 1

5 34764 15

Nous voulons maintenant lister toutes les commandes contenant des personnes - le cas échéant, à partir de
tables ci-dessus.

Nous utilisons la déclaration SELECT suivante :

SELECT Persons.LastName, Persons.FirstName, Orders.OrderNo

DE Personnes
JOINTURE DROITE Commandes

ON Persons.P_Id=Orders.P_Id

ORDONNER PAR Persons.LastName

Le jeu de résultats ressemblera à ceci :

Utiliser le langage de requête structuré avancé

 LastName FirstName OrderNo

Hansen Bonjour 22456

Hansen Salut 24562

Pettersen Kari 77895

Pettersen Kari 44678

34764

Le mot-clé RIGHT JOIN renvoie toutes les lignes de la table de droite (Commandes),
même s'il n'y a pas de correspondances dans la table de gauche (Personnes).

Mot clé SQL FULL JOIN

Mot-clé SQL FULL JOIN

Le mot-clé FULL JOIN renvoie des lignes lorsqu'il y a une correspondance dans l'une des tables.

Syntaxe de la jointure complète SQL

SÉLECTIONNER le nom_de_la_colonne(s)

DE table_name1
JOINDRE ENTIÈREMENT table_name2

SUR table_name1.column_name=table_name2.column_name

Exemple de FULL JOIN SQL

La table "Personnes" :

P_Id LastName FirstName Adresse Ville

1 Hansen Salut Timoteivn 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

Utilisation du langage de requête structuré avancé

 3 Pettersen Kari Storgt 20 Stavanger

La table "Commandes" :

O_Id OrderNo P_Id

1 77895 3

2 44678 3

3 22456 1

4 24562 1

5 34764 15

Maintenant, nous voulons lister toutes les personnes et leurs commandes, et toutes les commandes avec leurs
personnes.

Nous utilisons la déclaration SELECT suivante :

SELECT Persons.NomDeFamille, Persons.Prénom, Orders.NuméroDeCommande

DE Personnes

FULL JOIN Commandes

ON Persons.P_Id=Orders.P_Id

ORDONNER PAR Persons.LastName

Le jeu de résultats ressemblera à ceci :

NomDeFamille FirstName OrderNo

Hansen Bonjour 22456

Hansen Bonjour 24562

Pettersen Kari 77895

Utiliser le langage de requête structuré avancé

 Pettersen Kari 44678

Svendson Tove

34764

Le mot-clé FULL JOIN retourne toutes les lignes de la table de gauche (Personnes), et
toutes les lignes de la table de droite (Commandes). S'il y a des lignes dans "Personnes" qui ne
n'ont pas de correspondances dans "Commandes", ou s'il y a des lignes dans "Commandes" qui n'ont pas
les correspondances dans "Personnes", ces lignes seront également listées.

Opérateur SQL UNION

L'opérateur SQL UNION combine deux ou plusieurs instructions SELECT.

L'opérateur SQL UNION

L'opérateur UNION est utilisé pour combiner l'ensemble des résultats de deux ou plusieurs SELECT
déclarations.

Remarquez que chaque instruction SELECT dans l'UNION doit avoir le même
nombre de colonnes. Les colonnes doivent également avoir des types de données similaires. Aussi, le
les colonnes dans chaque instruction SELECT doivent être dans le même ordre.

Syntaxe de l'UNION SQL

SELECT nom_de_colonne(s) À PARTIR DE nom_de_table1

UNION
SÉLECTIONNER nom_de_colonne(s) FROM nom_de_table2

Remarque : L'opérateur UNION sélectionne uniquement des valeurs distinctes par défaut. Pour autoriser
valeurs dupliquées, utilisez UNION ALL.

Syntaxe SQL UNION ALL

SÉLECTIONNER nom_de_colonne(s) À PARTIR DE nom_de_table1

UNION TOUT
SÉLECTIONNER le nom_de_colonne(s) À PARTIR de nom_de_table2

Utiliser le langage de requête structuré avancé

PS : Les noms de colonnes dans le résultat d'un UNION sont toujours égaux à
noms de colonnes dans la première instruction SELECT dans l'UNION.

Exemple de SQL UNION

Regardez les tableaux suivants :

"Employees_Norway":

E_ID E_Name

01 Hansen, Ola

02 Svendson, Tove

03 Svendson, Stephen

04 Pettersen, Kari

"Employees_USA":

E_ID E_Name

01 Turner, Sally

02 Kent, Clark

03 Svendson, Stephen

04 Scott, Stephen

Nous voulons maintenant lister tous les différents employés en Norvège et aux États-Unis.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER E_Nom DE Employés_Norvège

UNION
SÉLECTIONNER E_Nom DE Employés_Etats-Unis

L'ensemble des résultats ressemblera à ceci :

Utiliser le langage de requête structuré avancé

 E_Name

Hansen, Ola

Svendson, Tove

Svendson, Stephen

Pettersen, Kari

Turner, Sally

Kent, Clark

Scott, Stephen

Remarque : cette commande ne peut pas être utilisée pour lister tous les employés en Norvège et aux États-Unis.
l'exemple ci-dessus nous avons deux employés avec des noms identiques, et seulement un de
Ils seront listés. La commande UNION sélectionne uniquement les valeurs distinctes.

Exemple de SQL UNION ALL

Maintenant, nous voulons lister tous les employés en Norvège et aux États-Unis :

SÉLECTIONNER E_Nom DE Employés_Norvège

UNION TOUT

SÉLECTIONNER E_Nom DE Employés_EU

Result

E_Name

Hansen, Ola

Svendson, Tove

Svendson, Stephen

Utilisation du langage de requête structuré avancé

 Pettersen, Kari

Turner, Sally

Kent, Clark

Svendson, Stephen

Scott, Stephen

Instruction SQL SELECT INTO

L'instruction SQL SELECT INTO peut être utilisée pour créer des copies de sauvegarde de
tables.

L'instruction SQL SELECT INTO

L'instruction SELECT INTO sélectionne des données d'une table et les insère dans une
table différente.

L'instruction SELECT INTO est le plus souvent utilisée pour créer des copies de sauvegarde de
tables.

Syntaxe SQL SELECT INTO

Nous pouvons sélectionner toutes les colonnes dans la nouvelle table :

SÉLECTIONNER *

DANS nouveau_nom_table [DANS base_de_données_externe]

DE ancien_nom_table

Ou nous pouvons sélectionner uniquement les colonnes que nous voulons dans la nouvelle table :

SÉLECTIONNER le nom_de_la_colonne(s)

DANS new_table_name [DANS externaldatabase]

DE ancien_nom_table

Utiliser le langage de requête structuré avancé

Exemple de SQL SELECT INTO
Faire une copie de sauvegarde - Maintenant, nous voulons faire une copie exacte des données dans notre
Table des "Personnes".

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER *

DANS Persons_Backup

DE Personnes

Nous pouvons également utiliser la clause IN pour copier la table dans une autre base de données :

SÉLECTIONNER *

DANS Persons_Backup DANS 'Backup.mdb'

DE Personnes

Nous pouvons également copier seulement quelques champs dans la nouvelle table :

SÉLECTIONNER NomDeFamille, Prénom

DANS Persons_Backup

DE Personnes

SQL SELECT INTO - Avec une clause WHERE

Nous pouvons également ajouter une clause WHERE.

La déclaration SQL suivante crée une table "Persons_Backup" contenant uniquement les
personnes qui vivent dans la ville "Sandnes" :

SÉLECTIONNER NomDeFamille, Prénom

Utiliser le langage de requête structuré avancé

 DANS Persons_Backup

DE Personnes

OÙ Ville='Sandnes'

SQL SELECT INTO - Tables jointes

Il est également possible de sélectionner des données à partir de plusieurs tables.

L'exemple suivant crée une table « Persons_Order_Backup » contenant des données

des deux tableaux "Personnes" et "Commandes" :

SÉLECTIONNER Persons.LastName, Orders.OrderNo

DANS Persons_Order_Backup

DE Personnes

JOIN INTERNE Commandes

ON Persons.P_Id=Orders.P_Id

Fonctions SQL
SQL a de nombreuses fonctions intégrées pour effectuer des calculs sur les données.

Fonctions d'agrégation SQL

Les fonctions d'agrégation SQL retournent une seule valeur, calculée à partir des valeurs dans un
colonne.

Fonctions d'agrégation utiles :

AVG() - Renvoie la valeur moyenne

COUNT() - Renvoie le nombre de lignes

PREMIER() - Renvoie la première valeur

Utiliser le langage de requête structuré avancé

 DERNIER() - Renvoie la dernière valeur

MAX() - Renvoie la plus grande valeur

MIN() - Renvoie la plus petite valeur

SOMME() - Renvoie la somme

Fonctions scalaires SQL

Les fonctions scalaires SQL renvoient une seule valeur, basée sur la valeur d'entrée.

Fonctions scalaires utiles :

UCASE() - Convertit un champ en majuscules

LCASE() - Convertit un champ en minuscules

MID() - Extraire des caractères d'un champ de texte

LEN() - Renvoie la longueur d'un champ de texte

ROUND() - Arrondit un champ numérique au nombre de décimales spécifié

MAINTENANT() - Renvoie la date et l'heure système actuelles

FORMAT() - Formate la façon dont un champ doit être affiché

Astuce : Les fonctions agrégées et les fonctions scalaires seront expliquées en détail.
dans les chapitres suivants.

Fonction SQL AVG()

La fonction AVG()

La fonction AVG() retourne la valeur moyenne d'une colonne numérique.

Syntaxe SQL AVG()

SELECT AVG(column_name) FROM table_name

Exemple de SQL AVG()

Utiliser le langage de requête structuré avancé
Nous avons la table « Commandes » suivante :

O_Id OrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Now we want to find the average value of the "OrderPrice" fields.

Nous utilisons la déclaration SQL suivante :

SELECT AVG(OrderPrice) AS OrderAverage FROM Orders

Le jeu de résultats ressemblera à ceci :

OrderAverage

950

Nous voulons maintenant trouver les clients qui ont une valeur OrderPrice supérieure à
la valeur moyenne du prix de commande.

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER Client DE Commandes

OÙ OrderPrice > (SÉLECTIONNER AVG(OrderPrice) DE Orders)

Le jeu de résultats ressemblera à ceci :

Client
Utiliser le langage de requête structuré avancé
 Hansen

Nilsen

Jensen

Fonction SQL COUNT()

La fonction COUNT() renvoie le nombre de lignes correspondant à un spécifié

critères.

Syntaxe SQL COUNT(column_name)

La fonction COUNT(column_name) renvoie le nombre de valeurs (NULL

les valeurs ne seront pas comptées) de la colonne spécifiée :

SELECT COUNT(nom_colonne) FROM nom_table

Syntaxe SQL COUNT(*)

La fonction COUNT(*) retourne le nombre d'enregistrements dans une table :

SELECT COUNT(*) FROM nom_table

Syntaxe SQL COUNT(DISTINCT nom_colonne)

La fonction COUNT(DISTINCT column_name) renvoie le nombre de valeurs distinctes

valeurs de la colonne spécifiée :

SELECT COUNT(DISTINCT nom_de_colonne) FROM nom_de_table

Remarque : COUNT(DISTINCT) fonctionne avec ORACLE et Microsoft SQL Server, mais

not with Microsoft Access.

Exemple de SQL COUNT(column_name)

Nous avons la table "Commandes" suivante :

Utilisation du langage de requête structuré avancé

 O_Id OrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Nous voulons maintenant compter le nombre de commandes du "Client Nilsen".

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER COUNT(Client) COMME CustomerNilsen DE Commandes

OÙ Client='Nilsen'

Le résultat de l'instruction SQL ci-dessus sera 2, car le client Nilsen a

a fait 2 commandes au total :

ClientNilsen

Exemple de SQL COUNT(*)

Si nous omettons la clause WHERE, comme ceci :

SELECT COUNT(*) AS NumberOfOrders FROM Orders

Le jeu de résultats ressemblera à ceci :

NumberOfOrders

Utilisation du langage de requête structuré avancé

 6

quel est le nombre total de lignes dans le tableau.

Exemple de SQL COUNT(DISTINCT nom_de_colonne)

Nous voulons maintenant compter le nombre de clients uniques dans la table "Commandes".

Nous utilisons la déclaration SQL suivante :

SELECT COUNT(DISTINCT Client) AS NombreDeClients

DE Commandes

Le jeu de résultats ressemblera à ceci :

NumberOfCustomers

quel est le nombre de clients uniques (Hansen, Nilsen et Jensen) dans le

table des "Commandes".

Fonction SQL FIRST()

La fonction FIRST()

La fonction FIRST() renvoie la première valeur de la colonne sélectionnée.

Syntaxe de SQL FIRST()

SÉLECTIONNER PREMIER(column_name) DE table_name

Exemple de SQL FIRST()

Nous avons le tableau "Commandes" suivant :

O_Id OrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

Utilisation du langage de requête structuré avancé

 2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Maintenant, nous voulons trouver la première valeur de la colonne "OrderPrice".

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER PREMIER(OrderPrice) COMME PremierPrixCommande DE Commandes

L'ensemble des résultats ressemblera à ceci :

FirstOrderPrice

1000

Fonction SQL LAST()

La fonction LAST()

La fonction LAST() renvoie la dernière valeur de la colonne sélectionnée.

Syntaxe de SQL LAST()

SÉLECTIONNER DERNIER(nom_de_colonne) DE nom_de_table

Exemple de SQL LAST()

Nous avons la table "Commandes" suivante :

O_Id OrderDate OrderPrice Client

Utiliser le langage de requête structuré avancé

 1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Maintenant, nous voulons trouver la dernière valeur de la colonne "OrderPrice".

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER DERNIER(OrderPrice) COMME DernierPrixDeCommande DE Commandes

Le jeu de résultats ressemblera à ceci :

LastOrderPrice

100

Fonction SQL MAX()

La fonction MAX()

La fonction MAX() retourne la plus grande valeur de la colonne sélectionnée.

Syntaxe de SQL MAX()

SÉLECTIONNEZ MAX(nom_colonne) FROM nom_table

Exemple de SQL MAX()

Nous avons le tableau suivant "Commandes" :

O_Id OrderDate OrderPrice Client

Utiliser le langage de requête structuré avancé

 1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Nous voulons maintenant trouver la plus grande valeur de la colonne "OrderPrice".

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER MAX(OrderPrice) COMME LargestOrderPrice DE Orders

Le jeu de résultats ressemblera à ceci :

LargestOrderPrice

2000

Fonction SQL MIN()

La fonction MIN()

La fonction MIN() retourne la plus petite valeur de la colonne sélectionnée.

Syntaxe de SQL MIN()

SELECT MIN(nom_de_colonne) FROM nom_de_table

Exemple de SQL MIN()

Nous avons le tableau suivant "Commandes" :

Utiliser le langage de requête structuré avancé

 O_Id OrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Maintenant, nous voulons trouver la plus petite valeur de la colonne "OrderPrice".

Nous utilisons la déclaration SQL suivante :

SELECT MIN(PriceCommande) AS PrixCommandeLePlusPetit DE

Orders

Le jeu de résultats aura l'apparence suivante :

SmallestOrderPrice

100

Fonction SQL SUM()

La fonction SUM()

La fonction SUM() renvoie la somme totale d'une colonne numérique.

Syntaxe de SQL SUM()

SELECT SUM(nom_de_colonne) FROM nom_de_table

Exemple de SQL SUM()

Utilisation du langage de requête structuré avancé
Nous avons la table "Commandes" suivante :

O_Id OrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Nous voulons maintenant trouver la somme de tous les champs "OrderPrice".

Nous utilisons la déclaration SQL suivante :

SÉLECTIONNER SOMME(OrderPrice) COMME OrderTotal DE Commandes

Le jeu de résultats ressemblera à ceci :

OrderTotal

5700

Instruction SQL GROUP BY

Les fonctions d'agrégation nécessitent souvent une instruction GROUP BY supplémentaire.

La déclaration GROUP BY

L'instruction GROUP BY est utilisée en conjonction avec les fonctions agrégées pour
regrouper le jeu de résultats par une ou plusieurs colonnes.

Syntaxe SQL GROUP BY

SÉLECTIONNEZ nom_colonne, fonction_aggrégée(nom_colonne)

Utiliser le langage de requête structuré avancé
 DE table_name

Où nom_de_colonne opérateur valeur

GROUPE PAR nom_de_colonne

Exemple de GROUP BY en SQL

Nous avons le tableau 'Commandes' suivant :

O_IdOrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Maintenant, nous voulons trouver le montant total (commande totale) de chaque client.

Nous devrons utiliser l'instruction GROUP BY pour regrouper les clients.

Nous utilisons la requête SQL suivante :

SÉLECTIONNER Client, SOMME( PrixDeCommande) DE Commandes

GROUPER PAR Client

Le jeu de résultats ressemblera à ceci :

Client SUM(PriceOrder)

Hansen 2000

Using Advanced Structured Query Language

 Nilsen 1700

Jensen 2000

Voyons ce qui se passe si nous omettons la clause GROUP BY :

SÉLECTIONNER Client, SOMME(PrixCommande) DE Commandes

Le jeu de résultats ressemblera à ceci :

Client SOMME(OrdrePrix)

Hansen 5700

Nilsen 5700

Hansen 5700

Hansen 5700

Jensen 5700

Nilsen 5700

Le jeu de résultats ci-dessus n'est pas ce que nous voulions.

Explication des raisons pour lesquelles la déclaration SELECT ci-dessus ne peut pas être utilisée : La SELECT
La déclaration ci-dessus a deux colonnes spécifiées (Client et SOMME(PriceCommande).
La "SUM(OrderPrice)" retourne une seule valeur (c'est-à-dire le montant total de la
"Colonne OrderPrice", tandis que "Customer" renvoie 6 valeurs (une valeur pour chaque ligne)
dans la table "Commandes"). Cela ne nous donnera donc pas le bon résultat. Cependant,
vous avez vu que l'instruction GROUP BY résout ce problème.

GROUPE PAR Plus D'une Colonne

Nous pouvons également utiliser l'instruction GROUP BY sur plus d'une colonne, comme ceci :

SÉLECTIONNER Client, DateDeCommande, SOMME(PrixCommande) DE

Commandes

GROUP BY Client, DateDeCommande

Utiliser le langage de requête structuré avancé
Clause HAVING SQL

La clause HAVING

La clause HAVING a été ajoutée à SQL parce que le mot-clé WHERE ne pouvait pas
être utilisé avec des fonctions d'agrégation.

Syntaxe SQL HAVING

SÉLECTIONNER nom_de_colonne, fonction_agrégée(nom_de_colonne)

DE nom_de_table

OÙ column_name opérateur valeur

GROUPE PAR nom_colonne

AYANT fonction_aggrégée(nom_de_colonne) opérateur

value

Exemple SQL HAVING

Nous avons la table suivante 'Commandes' :

O_Id OrderDate OrderPrice Client

1 2008/11/12 1000 Hansen

2 2008/10/23 1600 Nilsen

3 2008/09/02 700 Hansen

4 2008/09/03 300 Hansen

Utiliser le langage de requête structuré avancé
 5 2008/08/30 2000 Jensen

6 2008/10/04 100 Nilsen

Nous voulons maintenant vérifier si l'un des clients a un total de commandes inférieur à 2000.

Nous utilisons la déclaration SQL suivante :

SELECT Client, SUM(PrixCommande) FROM Commandes

GROUPE PAR Client

AYANT SOMME(OrderPrice)<2000

L'ensemble des résultats aura l'apparence suivante :

Client SOMME(OrdrePrix)

Nilsen 1700

Nous voulons maintenant savoir si les clients "Hansen" ou "Jensen" ont un total de commandes de
plus de 1500.

Nous ajoutons une clause WHERE ordinaire à l'instruction SQL :

SÉLECTIONNER Client, SOMME(PrixCommande) DE Commandes

OÙ Client='Hansen' OU Client='Jensen'

GROUPE PAR Client

AVOIR SOMME(OrderPrice)>1500

L'ensemble des résultats aura l'apparence suivante :

Client SOMME(OrdrePrix)

Utiliser le langage de requête structuré avancé

 Hansen 2000

Jensen 2000

Fonction SQL UCASE()

La fonction UCASE()

La fonction UCASE() convertit la valeur d'un champ en majuscules.

Syntaxe de SQL UCASE()

SÉLECTIONNER UPPER(nom_colonne) DE nom_table

Exemple de SQL UCASE()

Nous avons la table "Personnes" suivante :

P_Id NomDeFamillePrénom Adresse City

1 Hansen Ola Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Nous voulons maintenant sélectionner le contenu des colonnes "Nom" et "Prénom".

au-dessus, et convertir la colonne "LastName" en majuscules.

Nous utilisons la déclaration SELECT suivante :

SELECT UPPER(NomDeFamille) as NomDeFamille, Prénom

DE Personnes

Le jeu de résultats ressemblera à ceci :

LastName FirstName

HANSEN Bonjour

Utilisation du langage de requête structuré avancé

 SVENDSON Tove

PETTERSEN Kari

Fonction SQL LCASE()

La fonction LCASE()

La fonction LCASE() convertit la valeur d'un champ en minuscules.

Syntaxe LCASE() SQL

SÉLECTIONNER LCASE(nom_de_colonne) À PARTIR DE nom_de_table

Exemple de SQL LCASE()

Nous avons la table "Personnes" suivante :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Nous voulons maintenant sélectionner le contenu des colonnes "NomDeFamille" et "Prénom".

above, and convert the "LastName" column to lowercase.

Nous utilisons la déclaration SELECT suivante :

SELECT LCASE(LastName) as LastName, FirstName FROM

Personnes

Le jeu de résultats ressemblera à ceci :

Utilisation du langage de requête structuré avancé

 LastName FirstName

hansen Salut

svendson Tove

Pettersen Kari

Fonction SQL MID()

La fonction MID()

La fonction MID() est utilisée pour extraire des caractères d'un champ de texte.

Syntaxe de SQL MID()

SÉLECTIONNER MID(nom_colonne,début[,longueur]) À PARTIR DE nom_table

Paramètre Description

column_nameRequired. The field to extract characters from.

commencer Requis. Spécifie la position de départ (commence à 1).

length Facultatif. Le nombre de caractères à retourner. Si

omise, la fonction MID() renvoie le reste du texte.

Exemple de SQL MID()

Nous avons la table "Personnes" suivante :

P_Id LastName FirstName Adresse Ville

1 Hansen Bonjour Timothée 10 Sandnes

Utiliser le langage de requête structuré avancé

 2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Nous voulons maintenant extraire les quatre premiers caractères de la colonne "Ville" ci-dessus.

Nous utilisons la déclaration SELECT suivante :

Sélectionner MID(Ville,1,4) comme PetiteVille de Personnes

L'ensemble de résultats ressemblera à ceci :

PetiteVille

Sable

Sable

Stav

Fonction SQL LEN()

La fonction LEN()

La fonction LEN() renvoie la longueur de la valeur dans un champ de texte.

Syntaxe de SQL LEN()

SÉLECTIONNER LEN(nom_de_colonne) DE nom_de_table

Exemple de SQL LEN()

Nous avons la table "Personnes" suivante :

Utilisation du langage de requête structuré avancé
 P_IdLastName Prénom Adresse Ville

1 Hansen Ola Timothée 10 Sandnes

2 Svendson Tove Borgvn 23 Sandnes

3 Pettersen Kari Storgt 20 Stavanger

Nous voulons maintenant sélectionner la longueur des valeurs dans la colonne "Adresse" ci-dessus.

Nous utilisons la déclaration SELECT suivante :

SELECT LEN(Adresse) as LongueurDeLAdresse FROM Persons

Le jeu de résultats ressemblera à ceci :

LengthOfAddress

12

Fonction SQL ROUND()

La fonction ROUND()

La fonction ROUND() est utilisée pour arrondir un champ numérique au nombre de

décimales spécifiés.

Syntaxe de SQL ROUND()

SÉLECTIONNER ARRONDI(nom_colonne,décimales) DE nom_table

Paramètre Description

column_nameRequired. The field to round.

Utilisation du langage de requête structuré avancé
 décimales Requis. Spécifie le nombre de décimales à être
retourné.

Exemple de SQL ROUND()

Nous avons le tableau "Produits" suivant :

Prod_Id ProductNameUnit UnitPrice

1 Jarlsberg 1000 g 10.45

2 Mascarpone 1000 g 32,56

3 Gorgonzola 1000 g 15,67

Nous voulons maintenant afficher le nom du produit et le prix arrondi au nombre entier le plus proche.
entier.

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER NomDuProduit, ARRONDI(PrixUnitaire,0) comme PrixUnitaire

DE Produits

L'ensemble des résultats ressemblera à ceci :

ProductName UnitPrice

Jarlsberg 10

Mascarpone 33

Gorgonzola 16

Utilisation du langage de requête structuré avancé

 Fonction SQL NOW()

La fonction NOW()

La fonction NOW() renvoie la date et l'heure actuelles du système.

Syntaxe de SQL NOW()

SÉLECTIONNER MAINTENANT() DE nom_de_table

Exemple de SQL NOW()

Nous avons la table "Produits" suivante :

Prod_Id ProductName Unité PrixUnitaire

1 Jarlsberg 1000 g 10.45

2 Mascarpone 1000 g 32,56

3 Gorgonzola 1000 g 15,67

Nous voulons maintenant afficher les produits et les prix à la date d'aujourd'hui.

Nous utilisons la déclaration SELECT suivante :

Sélectionnez NomDuProduit, PrixUnitaire, Maintenant() comme DatePer FROM

Produits

L'ensemble des résultats ressemblera à ceci :

ProductName UnitPrice PerDate

Jarlsberg 10.45 10/07/2008 11:25:02 AM

Mascarpone 32.56 10/7/2008 11:25:02 AM

Gorgonzola 15.67 10/7/2008 11:25:02 AM

Utiliser le Langage de Requête Structuré Avancé

 Fonction FORMAT() SQL

La fonction FORMAT()
La fonction FORMAT() est utilisée pour formater la manière dont un champ doit être affiché.

Syntaxe de FORMAT() en SQL

SÉLECTIONNER FORMAT(column_name, format) DE table_name

Paramètre Description

column_name Required. The field to be formatted.

format requis. Spécifie le format.

Exemple de FORMAT() SQL

Nous avons la table "Produits" suivante :

Prod_Id ProductName Unité PrixUnitaire

1 Jarlsberg 1000 g 10h45

2 Mascarpone 1000 g 32,56

3 Gorgonzola 1000 g 15,67

Maintenant, nous voulons afficher les produits et les prix à la date d'aujourd'hui (avec la date d'aujourd'hui

date affichée au format suivant "AAAA-MM-JJ".

Nous utilisons la déclaration SELECT suivante :

SÉLECTIONNER NomDuProduit, PrixUnitaire, FORMAT(Aujourd'hui(),'AAAA-MM-

DD') en tant que PerDate

DE Produits

Utiliser le langage de requête structuré avancé

Le jeu de résultats ressemblera à ceci :

ProductName PrixUnitaire ParDate

Jarlsberg 10.45 2008-10-07

Mascarpone 32,56 2008-10-07

Gorgonzola 15,67 2008-10-07

Référence SQL rapide

SQL Syntaxe
Déclaration

ET / OU SÉLECTIONNER le(s) nom(s) de colonne

DE nom_de_table
CONDITION WHERE
CONDITION ET|OU

ALTÉRER MODIFIER LA TABLE table_name

TABLE AJOUTER nom_de_colonne type_de_données

ou

MODIFIER LA TABLE nom_de_table

SUPPRIMER LA COLONNE column_name

AS (alias) SELECT nom_colonne AS alias_colonne

DE table_name

ou

SÉLECTIONNER nom_de_colonne
DE table_name COMME table_alias

ENTRE SÉLECTIONNER nom_de_colonne(s)

DE nom_de_table
Où nom_de_colonne
Utiliser le langage de requête structuré avancé
 ENTRE la valeur1 ET la valeur2

CRÉER CRÉER UNE BASE DE DONNÉES nom_de_la_base_de_données

BASE DE DONNÉES
E

CRÉER UNE TABLE table_name

TABLE (
nom_de_colonne1 type_de_données
nom_de_colonne2 type_de_données,
nom_colonne2 type_de_données
...
)

CRÉER CRÉER UN INDEX nom_de_l_index

INDEX SUR table_nom (colonne_nom)

ou

CRÉER UN INDEX UNIQUE index_name

SUR table_name (column_name)

CRÉER UNE VUE view_name COMME

VUE SÉLECTIONNER le_nom_de_colonne(s)

DE nom_table
OÙ condition

SUPPRIMERSUPPRIMER DE table_name
OÙ some_column=some_value

ou

SUPPRIMER DE table_name
(Remarque : Supprime toute la table !!)

SUPPRIMER * DE nom_de_table
(Remarque: Supprime l'intégralité du tableau !!)

SUPPRIMER LA BASE DE DONNÉES nom_de_la_base_de_données

LAISSER TOMBER
BASE DE DONNÉES
E

SUPPRIMER INDEX table_name.index_name (SQL Server)

LAISSER TOMBER
Utilisation du langage de requête structuré avancé
INDEX SUPPRIMER L'INDEX index_name SUR table_name (MS
Accès)
SUPPRIMER L'INDEX index_name (DB2/Oracle)
MODIFIER LA TABLE nom_table
SUPPRIMER INDEX index_name (MySQL)

SUPPRIMERSUPPRIMER TABLE table_name

TABLE

GROUPE PAR SÉLECTIONNER nom_de_la_colonne,

fonction_agrégée(nom_colonne)
DE nom_de_table
OÙ nom_de_colonne opérateur valeur
GROUPE PAR nom_de_colonne

AVOIR SÉLECTIONNER nom_colonne,

fonction_agregat(nom_colonne)
DE nom_de_table
OÙ nom_de_colonne opérateur valeur
GROUPE PAR nom_colonne
AVOIR fonction_agrégée(nom_de_colonne)
valeur opérateur

DANS SÉLECTIONNER le nom_de_colonne(s)

DE table_name
OÙ nom_de_colonne
DANS (valeur1,valeur2,..)

INSÉRER INSÉRER DANS le_nom_de_table

DANS VALEURS (valeur1, valeur2, valeur3,....)

ou

INSÉRER DANS table_name

(column1, column2, column3,...)
VALEURS (valeur1, valeur2, valeur3,....)

INTÉRIEUR SELECT nom_de_colonne(s)

Utiliser le langage de requête structuré avancé
REJOINDREDE table_name1
JOIN interne table_name2
ON
table_name1.column_name=table_name2.column_n
prénom

LEFT JOIN SÉLECTIONNER nom_de_colonne(s)

DE table_name1
LEFT JOIN table_name2
SUR
table_name1.column_name=table_name2.column_n
nom

DROIT SÉLECTIONNER nom_de_colonne(s)

JOINDRE DE table_name1
JOIGNEZ DROIT table_name2
SUR
table_name1.column_name=table_name2.column_n
nom

FULL JOIN SÉLECTIONNER nom_de_colonne(s)

DE table_name1
FULL JOIN nom_table2
SUR
table_name1.column_name=table_name2.column_n
nom

LIKE SÉLECTIONNER le nom_de_colonne(s)

DE nom_de_table
OÙ column_name LIKE motif

ORDONNER PAR SÉLECTIONNER nom_de_colonne(s)

DE nom_de_table
ORDER BY nom_de_colonne [ASC|DESC]

SÉLECTIONNER le nom_de_colonne(s)
SÉLECTIONNER
DE nom_de_table

SÉLECTIONNER * SÉLECTIONNER *

DE nom_table

SÉLECTIONNER DISTINCT colonne_nom(s)

SÉLECTIONNER
Utilisation du langage de requête structuré avancé
DISTINCT DE nom_de_table

SÉLECTIONNER *
SÉLECTIONNER
DANS DANS nouveau_nom_de_table [DANS base_de_données_externe]
DE old_table_name

ou
SÉLECTIONNER le_nom_de_colonne(s)
DANS nouveau_nom_de_table [DANS externaldatabase]
DE old_table_name

SÉLECTIONNER TOP nombre|pourcentage nom_de_colonne(s)

SÉLECTIONNER
Haut DE nom_de_table

TRUNCAT TRUNCATE TABLE nom_de_table

E TABLE

UNION SÉLECTIONNER le_nom_de_colonne(s) DE table_nom1

UNION
SÉLECTIONNER nom_de_colonne(s) DE table_nom2

UNION SÉLECTIONNER nom_de_colonne(s) À PARTIR DE nom_de_table1

TOUT UNION TOUT

SÉLECTIONNER nom_de_colonne(s) DE nom_de_table2

METTRE À JOUR METTRE À JOUR nom_de_table

DEFINIR colonne1=valeur, colonne2=valeur,...
OÙ some_column=some_value

OÙ SÉLECTIONNER le nom_de_colonne(s)

DE nom_de_table
OÙ nom_colonne opérateur valeur

Utilisation du langage de requête structuré avancé

Référence
1. Fondamentaux de la conception de bases de données relationnelles

2. Fondamentaux de SQL Server 2005

3. Référence SQL de base

4. www.Microsoft .com

Utiliser le Langage de requête structuré avancé