Table des matières

COMME

OÙ

PAR GROUPE

AYANT

COMMANDÉ PAR

SÉLECTIONNER

Les résultats sont stockés dans une table de résultats, appelée ensemble de résultats.

grammaire

La syntaxe de l'instruction SELECT est la suivante :

SELECT column1, column2,...columnN FROM table_name;

column1, column2,...columnN sont les noms des champs de la table.
table_name est le nom de la table.

Si nous voulons lire toutes les données de la table, nous pouvons utiliser l'instruction SQL suivante :

SELECT * FROM table_name;

AVEC

Dans PostgreSQL, la clause WITH fournit un moyen d'écrire des instructions auxiliaires à utiliser dans des requêtes plus volumineuses.

La clause WITH aide à décomposer les requêtes volumineuses et complexes en formes plus simples et plus faciles à lire. Ces instructions sont généralement appelées expressions de table communes (Common Table Express, CTE) et peuvent également être utilisées comme table temporaire pour les requêtes.

La clause WITH est particulièrement utile lors de l'exécution d'une sous-requête plusieurs fois, ce qui nous permet de nous y référer par son nom (éventuellement plusieurs fois) dans la requête.

La clause WITH doit être définie avant de pouvoir être utilisée.

grammaire

La syntaxe de base d'une requête WITH est la suivante :

WITH
   name_for_summary_data AS (
      SELECT Statement)
   SELECT columns
   FROM name_for_summary_data
   WHERE conditions <=> (
      SELECT column
      FROM name_for_summary_data)
   [ORDER BY columns]

name_for_summary_data est le nom de la clause WITH, name_for_summary_data peut être le même que le nom de la table existante et a la priorité.

Les instructions INSERT, UPDATE ou DELETE de données peuvent être utilisées dans WITH, ce qui vous permet d'effectuer plusieurs opérations différentes dans la même requête.

AVEC récurrence

La sortie de données en elle-même peut être utilisée dans la clause WITH.

Une expression de table commune (CTE) présente l'avantage important de pouvoir se référencer elle-même, créant ainsi une CTE récursive. Un CTE récursif est une expression de table commune qui exécute à plusieurs reprises un CTE initial pour renvoyer un sous-ensemble de données jusqu'à ce qu'un ensemble de résultats complet soit obtenu.

LIMITE

La clause limit dans PostgreSQL est utilisée pour limiter la quantité de données interrogées dans l'instruction SELECT.

grammaire

La syntaxe de base d'une instruction SELECT avec une clause LIMIT est la suivante :

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

Voici la syntaxe de la clause LIMIT lorsqu'elle est utilisée avec la clause OFFSET :

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows] OFFSET [row num]

COMME

Dans la base de données PostgreSQL, si nous voulons obtenir des données contenant certains caractères, nous pouvons utiliser la clause LIKE .

Dans la clause LIKE, il est généralement utilisé en combinaison avec des caractères génériques, qui représentent n'importe quel caractère. Dans PostgreSQL, il existe principalement deux types de caractères génériques :

signe pourcentage %
souligner _

Si aucun des caractères génériques ci-dessus n'est utilisé, la clause LIKE et le signe égal = donnent le même résultat.

grammaire

Voici la syntaxe générale pour extraire des données de la base de données à l'aide de la clause LIKE avec le signe pourcentage % et le trait de soulignement _ :

SELECT FROM table_name WHERE column LIKE 'XXXX%';
--或者
SELECT FROM table_name WHERE column LIKE '%XXXX%';
--或者
SELECT FROM table_name WHERE column LIKE 'XXXX_';
--或者
SELECT FROM table_name WHERE column LIKE '_XXXX';
--或者
SELECT FROM table_name WHERE column LIKE '_XXXX_';

Vous pouvez spécifier n'importe quelle condition dans la clause WHERE.

Vous pouvez spécifier une ou plusieurs conditions en utilisant AND ou OR.

XXXX peut être n'importe quel nombre ou caractère.

OÙ

Dans PostgreSQL, lorsque nous devons interroger des données à partir d'une seule table ou de plusieurs tables selon des conditions spécifiées, nous pouvons ajouter une clause WHERE à l'instruction SELECT pour filtrer les données dont nous n'avons pas besoin.

La clause WHERE peut être utilisée non seulement dans l'instruction SELECT, mais également dans les instructions UPDATE, DELETE, etc.

grammaire

Voici la syntaxe générale pour lire les données de la base de données à l'aide de la clause WHERE dans l'instruction SELECT :

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1]

Nous pouvons utiliser des opérateurs de comparaison ou des opérateurs logiques tels que >, <, =, LIKE, NOT etc. dans la clause WHERE.

PAR GROUPE

Dans PostgreSQL, l'instruction GROUP BY est utilisée avec l'instruction SELECT pour regrouper les mêmes données.

GROUP BY est placé après la clause WHRER et avant la clause ORDER BY dans une instruction SELECT.

grammaire

Ci-dessous est la syntaxe de base de la clause GROUP BY -

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

La clause GROUP BY doit être placée après les conditions de la clause WHERE et avant la clause ORDER BY.

Dans la clause GROUP BY, vous pouvez grouper une ou plusieurs colonnes, mais les colonnes groupées doivent exister dans la liste des colonnes.

AYANT

La clause HAVING permet de filtrer les groupes de données après regroupement.

La clause WHERE définit les conditions sur les colonnes sélectionnées, tandis que la clause HAVING définit les conditions sur les regroupements créés par la clause GROUP BY.

grammaire

Voici où va la clause HAVING dans une requête SELECT :

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

La clause HAVING doit être placée après la clause GROUP BY et avant la clause ORDER BY. Voici la syntaxe de base de la clause HAVING dans l'instruction SELECT :

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Exemple:

Les enregistrements de la table COMPANY sont les suivants :

id | name  | age | address      | salary
 ----+-------+-----+--------------+--------
   1 | Paul  |  32 | California   |  20000
   2 | Allen |  25 | Texas        |  15000
   3 | Teddy |  23 | Norway       |  20000
   4 | Mark  |  25 | Rich-Mond    |  65000
   5 | David |  27 | Texas        |  85000
   6 | Kim   |  22 | South-Hall   |  45000
   7 | James |  24 | Houston      |  10000
   8 | Paul  |  24 | Houston      |  20000
   9 | James |  44 | Norway       |   5000
  10 | James |  45 | Texas        |   5000
(10 rows)

L'exemple suivant trouvera les données regroupées selon la valeur du champ nom, et le nombre de nom est supérieur à 1 :

SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) > 1;

Le résultat est le suivant :

 name
-------
 Paul
 James
(2 rows)

COMMANDÉ PAR

Dans PostgreSQL, ORDER BY est utilisé pour trier une ou plusieurs colonnes de données dans l'ordre croissant (ASC) ou décroissant (DESC).

grammaire

La syntaxe de base de la clause ORDER BY est la suivante :

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Vous pouvez utiliser une ou plusieurs colonnes dans ORDER BY, mais vous devez vous assurer que les colonnes à trier doivent exister.

ASC signifie ordre croissant, DESC signifie ordre décroissant.

Exemple:

Créez la table COMPANY, le contenu des données est le suivant :

 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

L'exemple suivant triera les résultats par ordre croissant en fonction de la valeur du champ NOM et de la valeur du champ SALAIRE :

SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

et obtenir le résultat suivant :

 id | name  | age |                      address                       | salary 
----+-------+-----+----------------------------------------------------+--------
  2 | Allen |  25 | Texas                                              |  15000
  5 | David |  27 | Texas                                              |  85000
  7 | James |  24 | Houston                                            |  10000
  6 | Kim   |  22 | South-Hall                                         |  45000
  4 | Mark  |  25 | Rich-Mond                                          |  65000
  1 | Paul  |  32 | California                                         |  20000
  3 | Teddy |  23 | Norway                                             |  20000
(7 rows)

Instructions et clauses PostgreSQL

SÉLECTIONNER

AVEC

LIMITE

COMME

OÙ

PAR GROUPE

AYANT

COMMANDÉ PAR

Je suppose que tu aimes