Comment filtrer les résultats d'une requête dans PostgreSQL

Introduction

Pour travailler avec des données dans une base de données, vous devez être en mesure de récupérer et de cibler efficacement des enregistrements spécifiques. En utilisant des clauses de filtrage dans vos requêtes, vous pouvez ajouter des critères spécifiques afin de ne renvoyer que les enregistrements les plus pertinents.

Dans ce guide, nous examinerons certaines des opérations de filtrage les plus courantes disponibles dans PostgreSQL et montrerons comment les utiliser pour affiner le champ de vos instructions. Nous montrerons comment tester les caractéristiques des enregistrements individuels avec WHERE clauses, comment regrouper des enregistrements pour résumer les informations avec GROUP BY , comment filtrer des groupes d'enregistrements avec le HAVING sous-clause, et comment définir le nombre maximum de lignes renvoyées avec le LIMIT clause.

Utilisation de WHERE clause pour définir les critères de correspondance

L'un des moyens les plus courants et les plus utiles pour indiquer les exigences de votre requête est le WHERE clause. Le WHERE La clause vous permet de définir des critères de recherche réels pour les instructions de requête en spécifiant des conditions qui doivent être vraies pour tous les enregistrements correspondants.

WHERE Les clauses fonctionnent en définissant des expressions booléennes qui sont comparées à chaque ligne de données candidate. Si le résultat de l'expression est faux, la ligne sera supprimée des résultats et ne sera pas renvoyée ou ne passera pas à l'étape suivante du traitement. Si le résultat de l'expression est vrai, elle satisfait les critères de la recherche et continuera pour tout traitement ultérieur en tant que ligne candidate.

La syntaxe de base du WHERE clause ressemble à ceci :

SELECT * FROM my_table WHERE <condition>;
 

Le <condition> peut être tout ce qui donne une valeur booléenne. Dans PostgreSQL, une valeur booléenne est l'un des TRUE , FALSE , ou NULL .

Les conditions sont souvent formées à l'aide d'un ou plusieurs des opérateurs suivants :

• = :égal à
• > :supérieur à
• < :moins de
• >= :supérieur ou égal à
• <= :inférieur ou égal à
• <> ou != :pas égal
• AND :l'opérateur logique "et" — joint deux conditions et renvoie TRUE si les deux conditions sont TRUE
• OR :opérateur logique "ou" - joint deux conditions et renvoie TRUE si au moins une des conditions est TRUE
• IN  :la valeur est contenue dans la liste, la série ou la plage qui suit
• BETWEEN  :la valeur est contenue dans la plage des valeurs minimales et maximales qui suivent, incluses
• IS NULL :correspond si la valeur est NULL
• NOT :nie la valeur booléenne qui suit
• EXISTS :la requête qui suit contient des résultats
• LIKE :correspond à un motif (en utilisant les caractères génériques % pour correspondre à 0 ou plusieurs caractères et _ pour correspondre à un seul caractère)
• ILIKE :correspond à un motif (en utilisant les caractères génériques % pour correspondre à 0 ou plusieurs caractères et _ pour correspondre à un seul caractère), insensible à la casse
• SIMILAR TO :correspond à un modèle utilisant le dialecte des expressions régulières de SQL
• ~  :correspond à un modèle utilisant des expressions régulières POSIX, sensibles à la casse
• ~*  :correspond à un modèle utilisant des expressions régulières POSIX, insensibles à la casse
• !~ :ne correspond pas à un modèle utilisant des expressions régulières POSIX, sensible à la casse
• !~*  :ne correspond pas à un modèle utilisant des expressions régulières POSIX, insensible à la casse

Alors que la liste ci-dessus représente certaines des constructions de test les plus courantes, il existe de nombreux autres opérateurs qui produisent des résultats booléens qui peuvent être utilisés en conjonction avec un WHERE clause.

Exemples utilisant WHERE

L'une des vérifications les plus courantes et les plus simples est l'égalité, en utilisant le = opérateur. Ici, nous vérifions si chaque ligne du customer la table a un last_name valeur égale à Smith :

SELECT * FROM customer WHERE last_name = 'Smith';
 

Nous pouvons ajouter des conditions supplémentaires à cela pour créer des expressions composées à l'aide d'opérateurs logiques. Cet exemple utilise le AND clause pour ajouter un test supplémentaire par rapport au first_name colonne. Les lignes valides doivent satisfaire les deux conditions :

SELECT * FROM customer WHERE first_name = 'John' AND last_name = 'Smith';
 

De même, nous pouvons vérifier si l'une d'une série de conditions est remplie. Ici, nous vérifions les lignes de l'address table pour voir si le zip_code la valeur est égale à 60626 ou le neighborhood colonne est égal à la chaîne "Roger's Park". Nous utilisons deux guillemets simples pour indiquer qu'un guillemet simple littéral doit être recherché :

SELECT * FROM address WHERE zip_code = '60626' OR neighborhood = 'Roger''s Park';
 

Le IN L'opérateur peut fonctionner comme une comparaison entre un certain nombre de valeurs, entourées de parenthèses. S'il y a une correspondance avec l'une des valeurs données, l'expression est TRUE :

SELECT * FROM customer WHERE last_name IN ('Smith', 'Johnson', 'Fredrich');
 

Ici, nous vérifions par rapport à un modèle de chaîne en utilisant LIKE . Le % fonctionne comme un caractère générique correspondant à zéro ou plusieurs caractères, donc "Pete", "Peter" et toute autre chaîne commençant par "Pete" correspondraient :

SELECT * FROM customer WHERE last_name LIKE 'Pete%';
 

Nous pourrions faire une recherche similaire en utilisant le ~* opérateur pour vérifier les correspondances à l'aide d'expressions régulières POSIX sans tenir compte de la casse. Dans ce cas, nous vérifions si la valeur de last_name commence par un "d" et contient la sous-chaîne "on", qui correspondrait à des noms tels que "Dickson", "Donald" et "Devon":

SELECT * FROM customer WHERE last_name ~* '^D.*on.*';
 

Nous pouvons vérifier si un numéro de rue se trouve dans le bloc de 4000 adresses en utilisant le BETWEEN et AND opérateurs pour définir une plage inclusive :

SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;
 

Ici, nous pouvons afficher n'importe quel customer entrées dont le numéro de sécurité sociale ne comporte pas 9 chiffres. Nous utilisons le LENGTH() opérateur pour obtenir le nombre de chiffres dans le champ et le <> pour vérifier l'inégalité :

SELECT * FROM customer WHERE LENGTH(SSN) <> 9;
 

Utilisation de GROUP BY clause pour résumer plusieurs enregistrements

Le GROUP BY La clause est une autre façon très courante de filtrer les résultats en représentant plusieurs résultats avec une seule ligne. La syntaxe de base du GROUP BY clause ressemble à ceci :

SELECT <columns> FROM some_table GROUP BY <columns_to_group>
 

Lorsqu'un GROUP BY est ajoutée à une instruction, elle indique à PostgreSQL d'afficher une seule ligne pour chaque valeur unique pour la ou les colonnes données. Cela a des implications importantes.

Depuis le GROUP BY est un moyen de représenter plusieurs lignes en une seule ligne, PostgreSQL ne peut exécuter la requête que s'il peut calculer une valeur pour chacune des colonnes qu'il est chargé d'afficher. Cela signifie que chaque colonne identifiée par le SELECT partie de la déclaration doit être :

• inclus dans le GROUP BY clause pour garantir que chaque ligne a une valeur unique
• résumé pour résumer toutes les lignes de chaque groupe

Concrètement, cela signifie que toutes les colonnes du SELECT liste non incluse dans le GROUP BY La clause doit utiliser une fonction d'agrégation pour produire un seul résultat pour la colonne de chaque groupe.

Exemples utilisant GROUP BY

Pour les exemples de cette section, supposons que nous ayons une table appelée pet que nous avons défini et peuplé comme suit :

CREATE TABLE pet (    id SERIAL PRIMARY KEY,    type TEXT,    name TEXT,    color TEXT,    age INT);INSERT INTO pet (type, name, color, age) VALUES('dog', 'Spot', 'brown', 3),('dog', 'Rover', 'black', 7),('dog', 'Sally', 'brown', 1),('cat', 'Sabrina', 'black', 8),('cat', 'Felix', 'white', 4),('cat', 'Simon', 'orange', 8),('rabbit', 'Buttons', 'grey', 4),('rabbit', 'Bunny', 'brown', 8),('rabbit', 'Briony', 'brown', 6);
 

L'utilisation la plus simple de GROUP BY est d'afficher la plage de valeurs uniques pour une seule colonne. Pour ce faire, utilisez la même colonne dans SELECT et GROUP BY . Ici, nous voyons toutes les couleurs utilisées dans le tableau :

SELECT color FROM pet GROUP BY color;
 

 color-------- black grey brown white orange(5 rows)
 

Lorsque vous vous déplacez au-delà d'une seule colonne dans le SELECT liste de colonnes, vous devez soit ajouter les colonnes au GROUP BY ou utilisez une fonction d'agrégation pour produire une valeur unique pour le groupe de lignes représentées.

Ici, nous ajoutons type au GROUP BY clause, ce qui signifie que chaque ligne représentera une combinaison unique de type et color valeurs. Nous ajoutons également l'age colonne, résumée par avg() fonction pour trouver l'âge moyen de chacun des groupes :

SELECT type, color, avg(age) AS average_age FROM pet GROUP BY type, color;
 

  type  | color  |     average_age--------+--------+-------------------- rabbit | brown  | 7.0000000000000000 cat    | black  | 8.0000000000000000 rabbit | grey   | 4.0000000000000000 dog    | black  | 7.0000000000000000 dog    | brown  | 2.0000000000000000 cat    | orange | 8.0000000000000000 cat    | white  | 4.0000000000000000(7 rows)
 

Les fonctions d'agrégat fonctionnent aussi bien avec une seule colonne dans le GROUP BY clause. Ici, on retrouve l'âge moyen de chaque type d'animal :

SELECT type, avg(age) AS average_age FROM PET GROUP BY type;
 

  type  |     average_age--------+-------------------- rabbit | 6.0000000000000000 dog    | 3.6666666666666667 cat    | 6.6666666666666667(3 rows)
 

Si nous voulons afficher le plus ancien de chaque type d'animal, nous pourrions plutôt utiliser le max() fonction sur l'age colonne. Le GROUP BY La clause regroupe les résultats dans les mêmes lignes qu'auparavant, mais la nouvelle fonction modifie le résultat dans l'autre colonne :

SELECT type, max(age) AS oldest FROM pet GROUP BY type;
 

  type  | oldest--------+------- rabbit |     8 dog    |     7 cat    |     8(3 rows)
 

Utilisation de HAVING clause pour filtrer des groupes d'enregistrements

Le GROUP BY La clause est un moyen de résumer les données en regroupant plusieurs enregistrements en une seule ligne représentative. Mais que se passe-t-il si vous souhaitez réduire ces groupes en fonction de facteurs supplémentaires ?

Le HAVING la clause est un modificateur pour le GROUP BY clause qui vous permet de spécifier les conditions que chaque groupe doit remplir pour être inclus dans les résultats.

La syntaxe générale ressemble à ceci :

SELECT <columns> FROM some_table GROUP BY <columns_to_group> HAVING <condition>
 

L'opération est très similaire à WHERE clause, à la différence que WHERE filtre les enregistrements uniques et HAVING filtre les groupes d'enregistrements.

Exemples utilisant HAVING

En utilisant le même tableau que nous avons présenté dans la dernière section, nous pouvons démontrer comment le HAVING la clause fonctionne.

Ici, on regroupe les lignes du pet tableau par valeurs uniques dans le type colonne, trouver la valeur minimale de age aussi bien. Le HAVING La clause filtre ensuite les résultats pour supprimer tous les groupes dont l'âge n'est pas supérieur à 1 :

SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
 

  type  | youngest--------+---------- rabbit |        4 cat    |        4(2 rows)
 

Dans cet exemple, nous regroupons les lignes dans pet par leur couleur. Nous filtrons ensuite les groupes qui ne représentent qu'une seule ligne. Le résultat nous montre toutes les couleurs qui apparaissent plus d'une fois :

SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
 

 color------- black brown(2 rows)
 

Nous pouvons effectuer une requête similaire pour obtenir les combinaisons de type et color qu'un seul animal a :

SELECT type, color FROM pet GROUP BY type, color HAVING count(color) = 1;
 

  type  | color--------+-------- cat    | black rabbit | grey dog    | black cat    | orange cat    | white(5 rows)
 

Utilisation de la LIMIT clause pour définir le nombre maximum d'enregistrements

La LIMIT La clause offre une approche différente pour réduire les enregistrements renvoyés par votre requête. Plutôt que d'éliminer des lignes de données en fonction de critères dans la ligne elle-même, le LIMIT La clause définit le nombre maximum d'enregistrements renvoyés par une requête.

La syntaxe de base de LIMIT ressemble à ceci :

SELECT * FROM my_table LIMIT <num_rows> [OFFSET <num_rows_to_skip>];
 

Ici, le <num_rows> indique le nombre maximum de lignes à afficher à partir de la requête exécutée. Ceci est souvent utilisé en conjonction avec ORDER BY clauses pour obtenir les lignes avec les valeurs les plus extrêmes dans une certaine colonne. Par exemple, pour obtenir les cinq meilleures notes à un examen, un utilisateur peut ORDER BY un score colonne puis LIMIT les résultats à 5.

Tant que LIMIT compte à partir du haut des résultats par défaut, le OFFSET facultatif Le mot-clé peut être utilisé pour décaler la position de départ qu'il utilise. En effet, cela vous permet de paginer dans les résultats en affichant le nombre de résultats défini par LIMIT puis en ajoutant le LIMIT nombre au OFFSET pour récupérer la page suivante.

Exemples utilisant LIMIT

Nous utiliserons le pet tableau précédent pour les exemples de cette section.

Comme mentionné ci-dessus, LIMIT est souvent combiné avec un ORDER BY clause pour définir explicitement l'ordre des lignes avant de trancher le nombre approprié. Ici, on trie le pet entrées selon leur age , du plus ancien au plus jeune. Nous utilisons alors LIMIT pour afficher les 5 animaux les plus anciens :

SELECT * FROM pet ORDER BY age DESC LIMIT 5;
 

  type  |  name   | color  | age | id--------+---------+--------+-----+---- cat    | Simon   | orange |   8 |  6 cat    | Sabrina | black  |   8 |  4 rabbit | Bunny   | brown  |   8 |  8 dog    | Rover   | black  |   7 |  2 rabbit | Briany  | brown  |   6 |  9(5 rows)
 

Sans ORDER BY clause, LIMIT effectuera des sélections de manière entièrement prévisible. Les résultats renvoyés peuvent être affectés par l'ordre des entrées dans la table ou par des index. Ce n'est pas toujours une mauvaise chose.

Si nous avons besoin d'un enregistrement pour un seul dog dans la table, nous pourrions construire une requête comme celle-ci. Gardez à l'esprit que même si le résultat peut être difficile à prévoir, il ne s'agit pas d'une sélection aléatoire et ne doit pas être utilisée comme telle :

SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
 

 type | name | color | age | id------+------+-------+-----+---- dog  | Spot | brown |   3 |  1(1 row)
 

Nous pouvons utiliser le OFFSET clause pour paginer les résultats. Nous incluons un ORDER BY clause pour définir un ordre spécifique pour les résultats.

Pour la première requête, nous limitons les résultats sans spécifier de OFFSET pour obtenir les 3 premières entrées les plus jeunes :

SELECT * FROM pet ORDER BY age LIMIT 3;
 

 type | name  | color | age | id------+-------+-------+-----+---- dog  | Sally | brown |   1 |  3 dog  | Spot  | brown |   3 |  1 cat  | Felix | white |   4 |  5(3 rows)
 

Pour obtenir les 3 plus jeunes suivants, on peut additionner le nombre défini dans LIMIT au OFFSET pour ignorer les résultats que nous avons déjà récupérés :

SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 3;
 

  type  |  name   | color | age | id --------+---------+-------+-----+---- rabbit | Buttons | grey  |   4 |  7 rabbit | Briany  | brown |   6 |  9 dog    | Rover   | black |   7 |  2(3 rows)
 

Si nous ajoutons le LIMIT au OFFSET encore une fois, nous obtiendrons les 3 résultats suivants :

SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 6;
 

  type  |  name   | color  | age | id--------+---------+--------+-----+---- cat    | Simon   | orange |   8 |  6 rabbit | Bunny   | brown  |   8 |  8 cat    | Sabrina | black  |   8 |  4(3 rows)
 

Cela nous permet de récupérer des lignes de données à partir d'une requête en morceaux gérables.

Conclusion

Il existe de nombreuses façons de filtrer et de restreindre les résultats que vous obtenez à partir des requêtes. Des clauses comme WHERE et HAVING évaluez les rangées ou les groupes de rangées potentiels pour voir s'ils satisfont à certains critères. Le GROUP BY La clause vous aide à résumer les données en regroupant les enregistrements qui ont une ou plusieurs valeurs de colonne en commun. La LIMIT La clause offre aux utilisateurs la possibilité de définir un maximum strict sur le nombre d'enregistrements à récupérer.

Apprendre comment ces clauses peuvent être appliquées, individuellement ou en combinaison, vous permettra d'extraire des données spécifiques à partir de grands ensembles de données. Les modificateurs et les filtres de requête sont essentiels pour transformer les données présentes dans PostgreSQL en réponses utiles.