Un guide étape par étape pour lire et comprendre les requêtes SQL - KDnuggets

Republié par Platon

Suiveurs: 0

Un guide étape par étape pour lire et comprendre les requêtes SQL
Image Freepik

SQL, ou Standard Query Language, est un langage de programmation permettant de gérer et de manipuler des données au sein d'un système de gestion de base de données relationnelle (SGBDR). Il s'agit d'un langage standard utilisé dans de nombreuses entreprises pour aider les entreprises à accéder facilement aux données. Parce qu'il est largement utilisé, l'emploi cite généralement SQL comme l'une des compétences nécessaires. C'est pourquoi il est essentiel de se renseigner sur SQL.

L’un des problèmes courants rencontrés lors de l’apprentissage de SQL est la compréhension des requêtes, principalement lorsqu’une autre personne les écrit. Nous travaillerions en équipe dans les entreprises et avons souvent besoin de lire et de comprendre leurs requêtes SQL. Nous devons donc nous entraîner à déconstruire les requêtes SQL et à les comprendre.

Cet article décrit un processus étape par étape pour lire et comprendre les requêtes SQL. Comment fait-on cela? Allons-y.

La première chose que nous devons faire lorsque nous rencontrons une requête SQL est de comprendre l’intention générale des requêtes SQL. L'intention générale ne signifie pas que nous connaissons entièrement la structure de la requête ; il s'agit davantage des flux globaux.

Nous devons comprendre les requêtes SQL standard pour comprendre la requête SQL générale. La plupart des requêtes SQL commencent par le SELECT clause et suivez avec le De clause. À partir de là, les requêtes sont le plus souvent suivies de INSCRIPTION, OÙ, PAR GROUPE, COMMANDÉ PAR, ainsi que les AYANT clauses.

Les clauses ci-dessus sont standards dans les requêtes SQL que nous devons comprendre. Pour chaque clause, leurs fonctions sont :

SELECT: Quelles colonnes doivent être extraites du tableau
De: De quelle table proviennent les données
INSCRIPTION: Combiner les tables avec l'identifiant spécifié
OÙ: Filtre de données basé sur la condition
PAR GROUPE: organisez les données en fonction de la valeur de la colonne et autorisez l'exécution de la fonction d'agrégation.
COMMANDÉ PAR : Organisez l'ordre des résultats des données en fonction de la colonne spécifique
AYANT: La condition de filtre pour la fonction d'agrégation qui ne peut pas être spécifiée avec OÙ

Ce sont les clauses standard et ce que vous devriez trouver au début pour comprendre la structure générale des requêtes SQL. Utilisons l'exemple de code pour en savoir plus.

SELECT 
  customers.name, 
  purchases.product, 
  SUM(price) as total_price 
FROM 
  purchases 
  JOIN customers ON purchases.cust_id = customers.id 
WHERE 
  purchases.category = 'kitchen' 
GROUP BY 
  customers.name, 
  purchases.product 
HAVING 
  total_price > 10000 
ORDER BY 
  total_price DESC;

Lorsque vous examinez la requête ci-dessus, essayez d'identifier les clauses standards. La clause vous permettrait de comprendre quelles données sont sélectionnées (SELECT), d'où il vient (De ainsi que les INSCRIPTION), et la condition (OÙ, PAR GROUPE, COMMANDÉ PARet la AYANT).

Par exemple, la lecture de la requête ci-dessus vous permettrait de comprendre les éléments suivants :

nous essayons d'obtenir trois types de données différents : le Nom d'une table appelée clients, le Produit d'une table appelée achats et l'agrégation de colonnes de prix qui n'identifient pas d'où vient la table et avec l'alias total_price (Informations de la clause SELECT).

Les données globales proviendraient des tables d'achats et de clients qui se rejoignent en utilisant la colonne cust_id des achats et la colonne id de la table du client (informations de la clause DE) ainsi que les INSCRIPTION).

Nous sélectionnerions uniquement les données avec la valeur de la colonne de catégorie dans le tableau des achats comme « cuisine » (informations de la clause OÙ),

groupe pour la fonction d'agrégation avec le nom et la colonne de produit provenant de la table respective (informations de la clause PAR GROUPE),

filtré également à partir de la somme des résultats de la fonction d'agrégation où le total_price est supérieur à 10000 XNUMX (informations de la clause AYANT), Et

trier les données par ordre décroissant selon le total_price (informations de la clause COMMANDÉ PAR).

C'est la structure générale des requêtes SQL que vous devez connaître et identifier. À partir de là, nous pouvons explorer davantage la requête avancée. Passons à l'étape suivante.

Il y aura un moment où vous rencontrerez une requête complexe où tant de SELECT des clauses existent dans la même requête. Dans ce cas, nous devons comprendre le résultat final de la requête ou le résultat final (premier) SELECT vous voyez dans la requête. La clé est de savoir quel sera le résultat de la requête.

Utilisons un code plus complexe comme celui ci-dessous.

WITH customerspending AS (
  SELECT 
    customers.id, 
    SUM(purchases.price) as total_spending 
  FROM 
    purchases 
    JOIN customers ON purchases.cust_id = customers.id 
  GROUP BY 
    customers.id
) 
SELECT 
  c.name, 
  pd.product, 
  pd.total_product_price, 
  cs.total_spending 
FROM 
  (
    SELECT 
      purchases.cust_id, 
      purchases.product, 
      SUM(purchases.price) as total_product_price 
    FROM 
      purchases 
    WHERE 
      purchases.category = 'kitchen' 
    GROUP BY 
      purchases.cust_id, 
      purchases.product 
    HAVING 
      SUM(purchases.price) > 10000
  ) AS pd 
  JOIN customers c ON pd.cust_id = c.id 
  JOIN customerspending cs ON c.id = cs.id 
ORDER BY 
  pd.total_product_price DESC;

La requête semble plus complexe et plus longue maintenant, mais l'accent initial devrait être mis sur le résultat final. SÉLECTIONNER, qui semble essayer de produire l’historique total des dépenses et des achats du client. Essayez d’évaluer ce que veut être le résultat final et décomposez-le à partir de là.

Nous avons un aperçu du résultat qui devrait provenir des requêtes. La prochaine partie est de voir quelles sont les conditions pour la finale SELECT sont. La clause de conditions, y compris OÙ, PAR GROUPE, COMMANDÉ PARet la AYANT étaient ceux qui contrôlaient le résultat global des données.

Essayez de lire et de comprendre les conditions de notre requête, et nous comprendrons mieux le résultat final de notre requête. Par exemple, dans notre requête SQL précédente, la condition finale est uniquement la COMMANDÉ PAR. Cela signifie que le résultat final serait classé par prix total du produit, par ordre décroissant.

Connaître les conditions finales vous aiderait à comprendre une partie importante de la requête et l'intention globale de la requête.

Enfin, nous devons comprendre d’où proviennent les données. Une fois que nous connaissons les données à sélectionner et les conditions pour les obtenir, nous devons comprendre la source. Le final INSCRIPTION La clause nous permettrait de comprendre comment les tables interagissent et le flux de données.

Par exemple, la requête complexe précédente montre que nous avons effectué Join deux fois. Cela signifie que nous avons utilisé au moins trois sources de données pour le résultat final. Ces informations seraient nécessaires dans les étapes ultérieures pour mieux comprendre comment chaque source de données provient, en particulier lorsque la source de données provient de la sous-requête.

Après avoir compris à quoi devrait ressembler le résultat final et d’où il vient, nous devons examiner de plus près les détails. À partir de là, nous reviendrions sur chaque sous-requête et comprendrions pourquoi elles sont structurées ainsi.

Cependant, nous n’essayons pas de les considérer dans des structures descendantes. Au lieu de cela, nous devrions essayer d'examiner les sous-requêtes les plus proches du résultat final, et nous passons à celle la plus éloignée du résultat final. À partir de l’exemple de code ci-dessus, nous devrions d’abord essayer de comprendre ce code :

SELECT 
  purchases.cust_id, 
  purchases.product, 
  SUM(purchases.price) as total_product_price 
FROM 
  purchases 
WHERE 
  purchases.category = 'kitchen' 
GROUP BY 
  purchases.cust_id, 
  purchases.product 
HAVING 
  SUM(purchases.price) > 10000

Ensuite, nous passons au code le plus éloigné qui est celui-ci :

WITH customerspending AS (
  SELECT 
    customers.id, 
    SUM(purchases.price) as total_spending 
  FROM 
    purchases 
    JOIN customers ON purchases.cust_id = customers.id 
  GROUP BY 
    customers.id
)

Nous pouvons retracer clairement le processus de réflexion de l'auteur lorsque nous décomposons chaque sous-requête de celle la plus proche du résultat à la plus éloignée.

Essayez de répéter le processus ci-dessus si vous avez besoin d'aide pour comprendre chaque sous-requête. Avec un peu de pratique, vous aurez une meilleure expérience dans la lecture et la compréhension de la requête.

Lire et comprendre les requêtes SQL est une compétence que tout le monde devrait posséder à l’ère moderne, car chaque entreprise s’en occupe. En utilisant le guide étape par étape suivant, vous aurez plus de temps pour comprendre les requêtes SQL complexes. Les étapes comprennent :

Comprendre la structure générale des requêtes SQL
Comprendre la sélection finale
Comprendre la clause des conditions finales
Comprendre la jointure finale
Lecture et répétition de l'ordre inverse

Cornellius Yudha Wijaya est un gestionnaire adjoint en science des données et un rédacteur de données. Tout en travaillant à plein temps chez Allianz Indonesia, il aime partager des conseils Python et Data via les réseaux sociaux et les supports d'écriture.