SQL Oracle : les requêtes essentielles du quotidien

Oracle est l’un des systèmes de gestion de bases de données les plus répandus dans les grandes entreprises. Que vous soyez développeur, analyste, consultant ou simplement amené à interroger une base Oracle, quelques ordres SQL reviennent en permanence. Les maîtriser, c’est gagner en autonomie et en efficacité au quotidien.

Cet article passe en revue les ordres SQL Oracle les plus utiles : interroger des données, filtrer, trier, joindre des tables, regrouper et agréger. Chaque commande est illustrée par un exemple concret avec son résultat, à partir d’un jeu de données fictif.

La grande majorité de ces ordres est stable depuis des décennies et fonctionne sur toutes les versions d’Oracle. Quand une syntaxe dépend d’une version précise (comme la clause FETCH FIRST, apparue en 12c), c’est signalé au fil de l’article.

Le jeu de données d’exemple

Tous les exemples s’appuient sur deux tables. Une table employes :

id	nom	service	service_id	salaire	date_embauche
101	Dupont	Informatique	1	3200	15/03/2019
102	Martin	Finance	2	2800	01/06/2021
103	Durand	Informatique	1	3500	10/01/2018
104	Leroy	Marketing	3	2600	05/09/2022
105	Moreau	Finance	2	3100	20/11/2020
106	Petit	Support	(vide)	2400	14/02/2023

Et une table services :

id	libelle
1	Informatique
2	Finance
3	Marketing

Notez que l’employé Petit a un service_id vide (le service « Support » n’existe pas encore dans la table services) : ce détail nous servira à illustrer les jointures.

SELECT : interroger les données

L’ordre SELECT est de loin le plus utilisé : il permet de lire des données. Sa forme la plus simple récupère toutes les colonnes de toutes les lignes d’une table :

SELECT * FROM employes;

L’astérisque * signifie « toutes les colonnes ». En pratique, mieux vaut nommer explicitement les colonnes dont on a besoin : c’est plus lisible et plus performant.

SELECT nom, service, salaire FROM employes;

Résultat :

nom	service	salaire
Dupont	Informatique	3200
Martin	Finance	2800
Durand	Informatique	3500
Leroy	Marketing	2600
Moreau	Finance	3100
Petit	Support	2400

Pour renommer une colonne dans le résultat (un alias), on utilise AS :

SELECT nom AS employe, salaire AS remuneration FROM employes;

WHERE : filtrer les lignes

La clause WHERE restreint les lignes retournées selon une condition. C’est l’un des outils les plus employés :

SELECT nom, salaire FROM employes WHERE service = 'Informatique';

Résultat : deux lignes seulement, celles du service Informatique.

nom	salaire
Dupont	3200
Durand	3500

On combine les conditions avec AND et OR, et on compare avec les opérateurs habituels (=, >, <, >=, <=, <> pour « différent de ») :

SELECT nom FROM employes WHERE salaire > 3000 AND service = 'Informatique';

Résultat : Dupont et Durand (les deux informaticiens gagnant plus de 3000).

Quelques opérateurs très pratiques dans un WHERE :

• BETWEEN pour un intervalle : WHERE salaire BETWEEN 2500 AND 3200 renverrait Dupont, Martin, Leroy et Moreau.
• IN pour une liste de valeurs : WHERE service IN ('Informatique', 'Finance').
• LIKE pour une recherche par motif : WHERE nom LIKE 'D%' renverrait Dupont et Durand (les noms commençant par D ; le % remplace n’importe quelle suite de caractères).
• IS NULL / IS NOT NULL pour tester l’absence ou la présence de valeur : WHERE service_id IS NULL renverrait Petit.

ORDER BY : trier les résultats

Pour trier le résultat, on utilise ORDER BY, suivi de ASC (croissant, par défaut) ou DESC (décroissant) :

SELECT nom, salaire FROM employes ORDER BY salaire DESC;

Résultat, du salaire le plus élevé au plus bas :

nom	salaire
Durand	3500
Dupont	3200
Moreau	3100
Martin	2800
Leroy	2600
Petit	2400

On peut trier sur plusieurs colonnes : d’abord par service, puis par salaire décroissant à l’intérieur de chaque service :

SELECT nom, service, salaire FROM employes ORDER BY service, salaire DESC;

Limiter le nombre de lignes

Besoin fréquent : ne récupérer que les premières lignes (par exemple les 3 plus hauts salaires). Oracle propose deux approches, selon la version.

La méthode historique, valable partout, utilise la pseudo-colonne ROWNUM :

SELECT * FROM (
  SELECT nom, salaire FROM employes ORDER BY salaire DESC
) WHERE ROWNUM <= 3;

Le tri doit être fait dans la sous-requête, car ROWNUM est attribué avant le tri. Sur notre jeu de données, on obtiendrait Durand, Dupont et Moreau. Depuis Oracle 12c, une syntaxe plus lisible et conforme au standard SQL est disponible, la clause FETCH FIRST :

SELECT nom, salaire FROM employes
ORDER BY salaire DESC
FETCH FIRST 3 ROWS ONLY;

Les deux fonctionnent ; la seconde est plus élégante si votre version d’Oracle la prend en charge. La clause FETCH FIRST n’est disponible qu’à partir d’Oracle 12c (2013) : sur une version antérieure (11g et avant), seule la forme avec ROWNUM est possible. À noter aussi que sur de très gros volumes, l’ancienne forme avec ROWNUM reste parfois plus performante — mais pour un usage courant, FETCH FIRST est parfait.

Les jointures : combiner plusieurs tables

Les données sont réparties dans plusieurs tables : les jointures permettent de les combiner. Le schéma ci-dessous illustre les quatre grands types de jointures, selon les lignes qu’ils conservent.

Chaque employé a un service_id pointant vers la table services. Il existe deux façons d’écrire une jointure en Oracle, et il est important de connaître les deux.

La syntaxe historique, dite « jointure Oracle », place les tables dans le FROM et la condition de liaison dans le WHERE :

SELECT e.nom, s.libelle
FROM employes e, services s
WHERE e.service_id = s.id;

C’est la forme la plus ancienne, et vous la rencontrerez très souvent dans le code Oracle existant. Elle fonctionne parfaitement, mais mélange la logique de jointure et les filtres dans le même WHERE, ce qui devient vite illisible quand les tables se multiplient.

La syntaxe ANSI (introduite dans Oracle avec la version 9i, en 2001) sépare clairement la jointure du filtrage, grâce aux mots-clés JOIN et ON :

SELECT e.nom, s.libelle
FROM employes e
INNER JOIN services s ON e.service_id = s.id;

Les deux requêtes ci-dessus donnent exactement le même résultat. Sur notre jeu de données, l’INNER JOIN renvoie cinq lignes — Petit n’apparaît pas, car son service_id est vide et ne correspond à aucun service :

nom	libelle
Dupont	Informatique
Martin	Finance
Durand	Informatique
Leroy	Marketing
Moreau	Finance

La jointure externe gauche (LEFT JOIN) garde toutes les lignes de la table de gauche, même sans correspondance à droite (les colonnes manquantes sont alors à NULL). Elle permet justement de retrouver les employés sans service affecté :

SELECT e.nom, s.libelle
FROM employes e
LEFT JOIN services s ON e.service_id = s.id
WHERE s.id IS NULL;

Résultat : une seule ligne, Petit avec un libellé vide — l’employé sans service rattaché.

La syntaxe historique disposait aussi de sa propre notation pour les jointures externes, avec l’opérateur (+) côté Oracle (par exemple WHERE e.service_id = s.id(+)). Vous pourrez la croiser dans d’anciens scripts, mais la forme ANSI LEFT JOIN / RIGHT JOIN lui est préférée aujourd’hui.

GROUP BY et les fonctions d’agrégat

Pour obtenir des synthèses (totaux, moyennes, comptages), on combine GROUP BY avec les fonctions d’agrégat. Les principales sont COUNT (compter), SUM (additionner), AVG (moyenne), MIN et MAX.

Compter le nombre d’employés par service :

SELECT service, COUNT(*) AS nb_employes
FROM employes
GROUP BY service;

Résultat :

service	nb_employes
Informatique	2
Finance	2
Marketing	1
Support	1

Calculer le salaire moyen par service :

SELECT service, AVG(salaire) AS salaire_moyen
FROM employes
GROUP BY service;

Résultat : Informatique 3350, Finance 2950, Marketing 2600, Support 2400.

Pour filtrer sur le résultat d’une agrégation, on n’utilise pas WHERE mais HAVING (qui s’applique après le regroupement). Par exemple, les services comptant plus d’un employé :

SELECT service, COUNT(*) AS nb
FROM employes
GROUP BY service
HAVING COUNT(*) > 1;

Résultat : Informatique (2) et Finance (2) uniquement. La distinction est importante : WHERE filtre les lignes avant le regroupement, HAVING filtre les groupes après.

DISTINCT : éliminer les doublons

Pour ne récupérer que les valeurs uniques d’une colonne, on utilise DISTINCT. Par exemple, la liste des services sans répétition :

SELECT DISTINCT service FROM employes;

Résultat : Informatique, Finance, Marketing, Support — chaque service une seule fois, alors qu’Informatique et Finance apparaissent deux fois dans la table.

Modifier les données : INSERT, UPDATE, DELETE

Au-delà de la lecture, trois ordres permettent de modifier les données. À manier avec prudence, surtout en production.

INSERT ajoute une ligne :

INSERT INTO employes (nom, service, salaire)
VALUES ('Bernard', 'Finance', 3000);

UPDATE modifie des lignes existantes. La clause WHERE est essentielle : sans elle, toutes les lignes de la table seraient modifiées.

UPDATE employes SET salaire = 3300 WHERE nom = 'Dupont';

DELETE supprime des lignes. Là encore, un DELETE sans WHERE vide toute la table :

DELETE FROM employes WHERE nom = 'Petit';

Point crucial propre à Oracle : ces modifications ne sont pas définitives tant que vous n’avez pas validé la transaction avec COMMIT. Tant que le COMMIT n’est pas fait, vous pouvez tout annuler avec ROLLBACK. C’est un filet de sécurité précieux : en cas d’erreur sur un UPDATE ou un DELETE, un ROLLBACK ramène les données à leur état précédent.

Quelques fonctions Oracle bien pratiques

Oracle propose de nombreuses fonctions intégrées. Parmi les plus utiles au quotidien :

• NVL(valeur, remplacement) : remplace une valeur nulle par une autre. NVL(service_id, 0) renvoie 0 pour Petit (dont le service_id est vide).
• SYSDATE : la date et l’heure courantes du serveur.
• TO_DATE et TO_CHAR : convertir entre texte et date, par exemple TO_CHAR(date_embauche, 'DD/MM/YYYY') pour formater une date.
• UPPER, LOWER, SUBSTR, TRIM : les fonctions classiques de manipulation de texte.
• ROUND, TRUNC : arrondir ou tronquer des nombres (et des dates).

En résumé

Une poignée d’ordres SQL couvre l’immense majorité des besoins quotidiens sur Oracle :

• SELECT avec WHERE pour lire et filtrer ;
• ORDER BY pour trier, FETCH FIRST ou ROWNUM pour limiter ;
• JOIN pour combiner des tables ;
• GROUP BY et les fonctions d’agrégat pour synthétiser ;
• INSERT, UPDATE, DELETE pour modifier, toujours avec un WHERE réfléchi et un COMMIT/ROLLBACK maîtrisé.

Ces ordres constituent la boîte à outils de base de quiconque travaille avec Oracle. Une fois ces réflexes acquis, on gagne énormément en autonomie pour explorer et exploiter les données. Le meilleur moyen de progresser reste la pratique : essayez ces requêtes sur une base de test, combinez-les, et observez les résultats.