SELECT et filtres simples | Exercices corrigés

Concepts & Exercices

SELECT * FROM table WHERE condition

Syntaxe de base

Opérateurs de comparaison

Égalité

Différent

<, >

Inférieur, Supérieur

<=, >=

Inférieur/égal, Supérieur/égal

SELECT nom, prenom, age FROM Etudiants WHERE age > 18;

Exercice 1

Sélectionner des colonnes spécifiques

Exercice 2

Appliquer des conditions simples

Exercice 3

Utiliser les opérateurs logiques AND/OR

Exercice 4

Utiliser l'opérateur LIKE pour les motifs

Exercice 5

Combiner plusieurs filtres complexes

Corrigé : Exercices 1 à 3

1 Sélection de colonnes

Définition :

SELECT colonnes : Clause qui spécifie les colonnes à récupérer dans le résultat d'une requête SQL.

Syntaxe de base :

SELECT colonne1, colonne2, ... FROM nom_table;

SELECT * FROM nom_table; /* Toutes les colonnes */

-- Sélectionner des colonnes spécifiques SELECT nom, prenom, email FROM Etudiants;

Étape 1 : Identifier les colonnes nécessaires

Déterminer quelles colonnes contiennent les données requises

Étape 2 : Lister les noms des colonnes

Énumérer les noms séparés par des virgules

Étape 3 : Spécifier la table source

Indiquer la table d'où proviennent les données

Étape 4 : Exécuter la requête

Envoyer la requête au moteur de base de données

Étape 5 : Analyser les résultats

Vérifier que les bonnes colonnes sont retournées

Réponse finale :

SELECT permet de spécifier exactement quelles colonnes récupérer

Règles appliquées :

• Performance : Sélectionner uniquement les colonnes nécessaires

• Nommage : Utiliser des alias pour clarifier les résultats

• Ordre : Les colonnes apparaissent dans l'ordre spécifié

2 Conditions simples

Définition :

WHERE : Clause qui filtre les lignes retournées selon une ou plusieurs conditions.

Exemples de conditions

age = 18

Égal à

note > 10

Supérieur à

ville != 'Paris'

Différent de

nom LIKE 'Jean%'

Motif correspondant

-- Sélectionner les étudiants de plus de 20 ans SELECT * FROM Etudiants WHERE age > 20;

Étape 1 : Identifier le critère de filtrage

Déterminer sur quelle colonne porte la condition

Étape 2 : Choisir l'opérateur de comparaison

Sélectionner l'opérateur approprié (=, <, >, etc.)

Étape 3 : Spécifier la valeur de comparaison

Indiquer la valeur avec laquelle comparer

Étape 4 : Construire la condition WHERE

Assembler la condition complète

Étape 5 : Tester la requête

Vérifier que les résultats sont corrects

WHERE = Condition + Comparaison + Valeur

Réponse finale :

WHERE filtre les lignes selon des critères spécifiques

Règles appliquées :

• Booléen : La condition doit retourner vrai ou faux

• Performance : Les conditions peuvent affecter les performances

• Indexation : Les colonnes filtrées peuvent bénéficier d'index

3 Opérateurs logiques

Définition :

AND/OR/NOT : Opérateurs logiques qui combinent plusieurs conditions dans une clause WHERE.

-- Combinaison de conditions avec AND SELECT * FROM Etudiants WHERE age > 18 AND ville = 'Lyon';

-- Combinaison de conditions avec OR SELECT * FROM Etudiants WHERE age < 18 OR ville = 'Paris';

-- Négation avec NOT SELECT * FROM Etudiants WHERE NOT (ville = 'Paris');

Analyser chaque condition individuellement

Déterminer la logique de combinaison

Appliquer les opérateurs logiques appropriés

Vérifier la priorité des opérateurs

Tester la requête avec des cas réels

Étape 1 : Identifier les conditions multiples

Déterminer quelles conditions doivent être combinées

Étape 2 : Choisir l'opérateur logique

AND pour conditions toutes vraies, OR pour au moins une vraie

Étape 3 : Gérer la priorité

Utiliser des parenthèses pour clarifier l'ordre d'évaluation

Étape 4 : Construire la condition complexe

Assembler les conditions avec les opérateurs logiques

Étape 5 : Vérifier les résultats

S'assurer que la logique correspond aux attentes

AND = Toutes vraies | OR = Au moins une vraie | NOT = Inverse

Réponse finale :

Les opérateurs logiques permettent des filtres complexes

Règles appliquées :

• Priorité : NOT > AND > OR (sans parenthèses)

• Parenthèses : Utiliser pour clarifier l'ordre d'évaluation

• Clarté : Les requêtes complexes doivent être lisibles

Corrigé : Exercices 4 à 5

4 Opérateur LIKE

Définition :

LIKE : Opérateur qui permet de rechercher des motifs dans des chaînes de caractères.

Caractères jokers

Zéro ou plusieurs caractères

Exactement un caractère

-- Chercher les noms commençant par 'J' SELECT * FROM Etudiants WHERE nom LIKE 'J%';

-- Chercher les emails contenant 'gmail' SELECT * FROM Etudiants WHERE email LIKE '%gmail%';

-- Chercher les noms de 5 lettres commençant par 'Mar' SELECT * FROM Etudiants WHERE nom LIKE 'Mar__';

Étape 1 : Identifier le motif à rechercher

Déterminer le modèle de correspondance requis

Étape 2 : Choisir les caractères jokers appropriés

% pour plusieurs caractères, _ pour un seul

Étape 3 : Construire l'expression LIKE

Assembler le motif avec la colonne à filtrer

Étape 4 : Tester la correspondance

Vérifier que le motif fonctionne comme prévu

Étape 5 : Optimiser si nécessaire

Considérer les performances pour les grandes tables

LIKE = Motif + Jokers + Correspondance

Réponse finale :

LIKE permet des recherches partielles dans les chaînes de caractères

Règles appliquées :

• Sensibilité : Dépend du SGBD (majuscules/minuscules)

• Performance : Moins performant que les égalités exactes

• Jokers : % correspond à zéro ou plus, _ à un caractère

5 Filtres complexes

Définition :

Filtres complexes : Combinaison de plusieurs conditions avec des opérateurs logiques et des comparaisons avancées.

-- Filtre complexe combinant plusieurs conditions SELECT nom, prenom, age, ville FROM Etudiants WHERE (age >= 18 AND age <= 25) AND (ville = 'Paris' OR ville = 'Lyon') AND nom LIKE 'M%';

Étape 1 : Analyser les exigences multiples

Identifier toutes les conditions à combiner

Étape 2 : Organiser la logique

Regrouper les conditions connexes avec des parenthèses

Étape 3 : Choisir les opérateurs appropriés

AND pour les conditions cumulatives, OR pour les alternatives

Étape 4 : Construire la requête étape par étape

Assembler progressivement les différentes parties

Étape 5 : Tester et valider

Vérifier que la requête retourne les résultats attendus

Étape 6 : Optimiser la performance

Considérer les index et les sous-requêtes si nécessaire

Filtre complexe = Logique + Parenthèses + Performance

Réponse finale :

Les filtres complexes combinent plusieurs critères pour des sélections précises

Règles appliquées :

• Parenthèses : Essentielles pour la priorité des opérations

• Clarté : Structurer la requête pour faciliter la lecture

• Performance : Considérer l'impact sur les grandes tables

Cours bien détaillé

SELECT = Σ(Filtresᵢ) | i ∈ Conditions

Sélection avec filtres

🔍

SELECT : Clause pour spécifier les colonnes à récupérer.

FilterWhere

WHERE : Clause pour filtrer les lignes selon des conditions.

🧮

Opérateurs : =, <>, <, >, <=, >= pour les comparaisons.

🔗

Logiques : AND, OR, NOT pour combiner les conditions.

💡

Conseil : Utiliser des alias pour clarifier les requêtes complexes

🔍

Attention : Les parenthèses sont cruciales pour la logique des conditions

⚡

Astuce : Utiliser LIMIT pour limiter les résultats pendant les tests

📋

Méthode : Décomposer les conditions complexes en parties simples

✅

Vérification : Toujours tester les requêtes avec des données réelles

Ordre des clauses :

SELECT : Quelles colonnes récupérer
FROM : D'où proviennent les données
WHERE : Quelles lignes filtrer
ORDER BY : Dans quel ordre trier (optionnel)
LIMIT : Combien de lignes retourner (optionnel)

Règles importantes :

La clause WHERE est exécutée après FROM mais avant SELECT
Les conditions sont évaluées de gauche à droite avec priorité des opérateurs
Les chaînes de caractères doivent être entourées de guillemets simples
Les dates doivent être au format standard (YYYY-MM-DD)
Les conditions complexes doivent être clairement parenthésées

SELECT et filtres simplesExercices corrigés

Opérateurs de comparaison

Exemples de conditions

Caractères jokers

SELECT et filtres simples
Exercices corrigés