Sélectionner la Syntaxe de Clause

S'applique À : WatchGuard Advanced EPDR

Cette rubrique décrit la syntaxe générale d'une instruction SELECT de SQL.

SELECT [DISTINCT] expr_list
	[FROM [db.] table | (subquery) | table_function]
	[SAMPLE sample_coeff]
	[GLOBAL] [ANY|ALL] [INNER|LEFT|RIGHT|FULL|CROSS] [OUTER] JOIN (subquery)|table USING columns_list
	[PREWHERE expr]
	[WHERE expr]
	[GROUP BY expr_list] [WITH TOTALS]
	[HAVING expr]
	[ORDER BY expr_list]
	[LIMIT [n, ]m]
	[UNION ALL...]
	[LIMIT n BY columns]

Vous pouvez utiliser ces clauses dans une requête SQL :

Clause FROM

La clause FROM spécifie la source à partir de laquelle les données doivent être lues (par exemple une table, une sous-requête ou une clause JOIN). Les sous-requêtes doivent être spécifiées entre parenthèses. Contrairement au langage SQL standard, il n'est pas nécessaire de spécifier un synonyme après une sous-requête. À des fins de compatibilité, vous pouvez saisir « name AS » après une sous-requête, mais le nom spécifié ne sera pas utilisé.

Clause SAMPLE

La clause SAMPLE traite les requêtes pour les données approximatives.

Lorsque vous utilisez la clause SAMPLE, la requête n'est pas effectuée sur l'ensemble des données, mais sur un pourcentage de celles-ci (l'échantillon). Par exemple, si vous devez calculer des statistiques portant sur un certain nombre d'événements, il vous suffit d'exécuter la requête sur 10 % de tous les événements puis de multiplier le résultat par 10.

Le traitement approximatif des requêtes peut être utile dans les cas suivants :

  • Lorsque vous souhaitez accélérer la collecte des résultats.
  • Lorsque vos données brutes ne sont pas exactes, l'approximation ne dégrade pas significativement la qualité des résultats.

Les caractéristiques de l'échantillonnage des données sont les suivantes :

  • Il s'agit d'un mécanisme déterministe. Le résultat d'une requête donnée est toujours le même.
  • Elle fonctionne de manière systématique pour différentes tables. Pour les tables possédant une clé d'échantillonnage unique, un échantillon présentant un coefficient donné sélectionne toujours le même sous-ensemble de données possibles. Cela signifie que vous pouvez utiliser l'échantillon dans les sous-requêtes de la clause IN. Vous pouvez également utiliser la clause JOIN pour joindre des échantillons.
  • Elle lit moins de données sur le disque. Vous devez spécifier correctement la clé d'échantillonnage.

Syntaxe de la clause SAMPLE :

Syntaxe Description

SAMPLE k

Nombre compris entre 0 et 1. La requête est exécutée sur un pourcentage k de données. Par exemple, SAMPLE 0.1 exécute la requête sur 10 % des données.

SAMPLE n

n est un nombre entier suffisamment grand. La requête est exécutée sur un échantillon d'au moins n lignes (mais pas beaucoup plus). Par exemple, SAMPLE 10000000 exécute la requête sur un minimum de 10 000 000 de lignes.

SAMPLE k OFFSET m

k et m sont des nombres compris entre 0 et 1. La requête est exécutée sur un échantillon de k pourcent des données. Les données utilisées pour l'échantillon sont décalées de m pourcent.

Clause JOIN

JOIN désigne une opération de jointure en algèbre relationnelle qui combine des colonnes d'une ou plusieurs tables et crée un nouveau groupe qui peut être stocké dans une table ou utilisé tel quel. Pour créer une nouvelle table, JOIN utilise les valeurs communes à plusieurs tables puis combine les colonnes.

Les types de clause JOIN pris en charge sont les suivants :

  • INNER JOIN (ou JOIN) — Compare chaque ligne de la table A avec les lignes de la table B de manière à trouver toutes les paires de lignes qui répondent au prédicat de jointure spécifié dans la clause ON. Lorsque le prédicat de jointure correspond à des valeurs non NULL, les valeurs des colonnes de chaque paire de lignes correspondante des tables A et B sont combinées dans une ligne de résultat.
  • LEFT JOIN (ou LEFT OUTER JOIN) — Contient toujours toutes les lignes de la table de gauche (A), même si la condition de jointure ne correspond pas aux lignes de la table de droite (table B). Cela signifie que si la clause ON correspond à 0 (zéro) ligne dans la table B (pour une ligne donnée de la table A), la jointure retournera toujours une ligne dans le résultat (pour cette ligne), mais avec NULL dans chaque colonne de la table B.
  • RIGHT JOIN (ou RIGHT OUTER JOIN) — Contient toujours toutes les lignes de la table de droite (table B), même si la condition de jointure ne correspond pas aux lignes de la table de gauche (table A). Cela signifie que si la clause ON correspond à 0 (zéro) ligne dans la table A (pour une ligne donnée de la table B), la jointure retournera toujours une ligne dans le résultat (pour cette ligne), mais avec NULL dans chaque colonne de la table A.
  • FULL JOIN (ou FULL OUTER JOIN) — Combine l'effet de LEFT JOIN et de RIGHT JOIN. Lorsque les lignes des tables jointes externes complètes ne correspondent pas, l'ensemble de résultats contiendra des valeurs NULL pour chaque colonne de la table ne contenant pas de ligne correspondante. Pour les lignes correspondantes, une seule ligne contenant les colonnes issues des deux tables est produite dans l'ensemble de résultats.
  • CROSS JOIN (ou,) — Retourne le produit cartésien des lignes des tables de la jointure. Il produit des lignes qui combinent chaque ligne de la première table avec chaque ligne de la deuxième table.
  • Modificateur ANY ou ALL — Si ALL est spécifié et que la table de droite comporte plusieurs lignes correspondantes, les données sont multipliées par le nombre de lignes. Il s'agit du comportement normal d'une clause JOIN en SQL standard. Si ANY est spécifié et que la table de droite comporte plusieurs lignes correspondantes, seule la première ligne trouvée est jointe. Si la table de droite ne possède qu'une seule ligne correspondante, les résultats de ANY et ALL sont identiques.

Clause WHERE

S'il existe une clause WHERE, elle doit contenir une expression de type UInt8. Il s'agit généralement d'une expression contenant des opérateurs logiques et de comparaison. Cette expression permet de filtrer les données avant toutes les transformations figurant dans l'instruction.

Clause PREWHERE

Cette clause présente la même signification que la clause WHERE. La différence réside dans les données lues à partir de la table. Avec PREWHERE, les colonnes nécessaires à l'exécution de la clause sont lues en premier. Les colonnes nécessaires à l'exécution du reste de la requête sont lues ensuite lorsque l'expression PREWHERE est vraie.

PREWHERE filtre les données plus efficacement et lit moins de données sur le disque lors de l'exécution de la requête.

Clause GROUP BY

Cette clause regroupe les résultats dans une ou plusieurs colonnes. Pour le regroupement, Endpoint Security interprète NULL comme une valeur.

Si le modificateur WITH TOTALS est spécifié, une autre ligne est calculée. Cette ligne comporte des colonnes clés qui contiennent des valeurs par défaut (des zéros ou des lignes vides) ainsi que des colonnes de fonctions agrégées avec des valeurs calculées sur toutes les lignes (les valeurs de Total). Cette ligne supplémentaire est produite uniquement dans les formats JSON, TabSeparated et Pretty. Dans les formats JSON, cette ligne est produite sous la forme d'un champ Total distinct. Dans les formats TabSeparated, la ligne figure après le résultat principal, précédée d'une ligne vide. Dans les formats Pretty, la ligne est produite dans une table distincte après le résultat principal.

Vous pouvez utiliser WITH TOTALS dans les sous-requêtes, y compris celles de la clause JOIN (dans ce cas, les valeurs totales respectives sont combinées).

Caution: Contrairement à MySQL (et à SQL standard), l'instruction GROUP BY ne prend pas en charge les arguments de position. Par exemple, GROUP BY 1, 2 est interprété comme un groupe par constante (c'est-à-dire toutes les lignes en une seule).

Clause LIMIT N BY Columns

Cette clause sélectionne les N premières lignes de chaque groupe de colonnes. LIMIT N BY n'est pas lié à LIMIT. Les deux instructions peuvent être utilisées dans la même requête. LIMIT N BY peut contenir n'importe quel nombre de colonnes ou d'expressions.

Clause HAVING

Cette clause permet de filtrer les résultats de l'agrégation produite par GROUP BY. Elle est similaire à la clause WHERE, avec une différence : WHERE est exécuté avant l'agrégation (GROUP BY), tandis que HAVING est exécuté après. Il est impossible d'utiliser HAVING si l'agrégation n'est pas effectuée.

Caution: Contrairement à MySQL (et conformément à la norme SQL), l'instruction GROUP BY ne prend pas en charge les arguments de position.

Clause ORDER BY

La clause ORDER BY contient une liste d'expressions, dont chacune peut être dotée d'un modificateur DESC (décroissant) ou ASC (croissant) de manière à déterminer le sens du tri. Si le sens n'est pas spécifié, ASC est présumé. Le sens du tri s'applique à une seule expression et non à l'ensemble de la liste.

Les lignes possédant des valeurs identiques pour la liste des expressions de tri sont produites dans un ordre arbitraire, qui peut également être différent à chaque fois. Si la clause ORDER BY est omise, l'ordre des lignes est également indéfini et peut être différent à chaque fois.

COLLATE

Lorsque vous triez des valeurs de chaîne, vous pouvez utiliser COLLATE pour spécifier l'alphabet que vous souhaitez utiliser. Par exemple, utilisez ORDER BY PhraseRecherchée COLLATE 'tr' pour trier par mot-clé par ordre croissant avec l'alphabet turc et sans tenir compte de la casse. Cela suppose que les chaînes sont encodées au format UTF-8.

Vous pouvez spécifier ou ne pas spécifier COLLATE pour chaque expression de manière indépendante. Si vous spécifiez ASC ou DESC, spécifiez COLLATE après. Lorsque vous utilisez COLLATE, le tri est toujours insensible à la casse.

Nous vous recommandons d'utiliser COLLATE uniquement pour le tri final d'un petit nombre de lignes, car le tri avec COLLATE est moins efficace que le tri normal par octets.

Ordre de tri NaN et NULL :

  • Avec le modificateur NULLS FIRST — D'abord NULL, puis NaN puis les autres valeurs.
  • Avec le modificateur NULLS LAST — D'abord les valeurs, puis NaN puis NULL.
  • Par Défaut — Identique au modificateur NULLS LAST.

Lorsque les nombres à virgule flottante sont triés, les NaN sont séparés des autres valeurs. Quel que soit l'ordre de tri, les NaN figurent à la fin. Avec le tri croissant, ils sont placés comme s'ils étaient supérieurs à tous les autres nombres, tandis qu'avec le tri décroissant, ils sont placés comme s'ils étaient inférieurs aux autres nombres.

Clause SELECT

Les expressions spécifiées dans la clause SELECT sont calculées une fois que toutes les opérations des clauses précédemment décrites sont effectuées. Si les expressions de la clause SELECT contiennent des fonctions d'agrégation, la solution traite les fonctions d'agrégation et les expressions utilisées en arguments lors de l'agrégation GROUP BY. Ces expressions fonctionnent comme si elles s'appliquaient à des lignes distinctes dans le résultat.

Clause DISTINCT

Si vous spécifiez DISTINCT, seule une ligne persiste parmi tous les ensembles de lignes entièrement correspondantes du résultat. Il est possible d'obtenir le même résultat en appliquant GROUP BY au même ensemble de valeurs que celui spécifié dans la clause SELECT, sans utiliser de fonctions d'agrégation. La clause DISTINCT présente les différences suivantes par rapport à la clause GROUP BY :

  • DISTINCT peut être appliqué en même temps que GROUP BY.

  • Lorsque vous omettez ORDER BY et définissez LIMIT, la requête s'arrête immédiatement suite à la lecture du nombre requis de lignes différentes.

  • Les blocs de données sont produits au fur et à mesure de leur traitement, sans attendre la fin de la requête complète.

DISTINCT fonctionne avec NULL comme si NULL était une valeur spécifique. En d'autres termes, dans les résultats DISTINCT, les différentes combinaisons avec NULL ne figurent qu'une seule fois.

Clause LIMIT m

Cette clause sélectionne les m premières lignes du résultat.

LIMIT n, m sélectionne les m premières lignes du résultat après avoir ignoré les n premières lignes. La syntaxe LIMIT m OFFSET n est équivalente. n et m doivent être des entiers non négatifs.

En l'absence de clause ORDER BY qui trie explicitement les résultats, le choix des lignes du résultat peut être arbitraire et non déterministe.

Clause UNION ALL

Vous pouvez utiliser cette clause pour combiner un nombre quelconque de requêtes. Seule la fonction UNION ALL est prise en charge. La fonction UNION (UNION DISTINCT) n'est pas prise en charge. Si vous avez besoin de UNION DISTINCT, vous pouvez saisir SELECT DISTINCT à partir d'une sous-requête contenant UNION ALL. Les requêtes appartenant à UNION ALL peuvent être exécutées simultanément et leurs résultats peuvent être mélangés.

La structure des résultats (le nombre et le type de colonnes) doit correspondre pour les requêtes, tandis que les noms des colonnes peuvent être distincts. Dans ce cas, les noms des colonnes du résultat final sont extraits de la première requête. Les unions font l'objet d'une conversion de type. Par exemple, si deux requêtes sont combinées avec le même champ de type non-Nullable et Nullable à partir d'un type compatible, la fonction UNION ALL correspondante possède un champ de type Nullable.

Il est impossible de mettre entre parenthèses les requêtes figurant dans UNION ALL. ORDER BY et LIMIT sont appliqués à des requêtes distinctes et non au résultat final. Si vous devez appliquer une conversion au résultat final, vous pouvez placer toutes les requêtes contenant UNION ALL dans une sous-requête de la clause FROM.

Opérateurs IN

Cette section décrit les opérateurs IN, NOT IN, GLOBAL IN et GLOBAL NOT IN.

Le côté gauche de l'opérateur IN est une colonne unique ou un tuple. Par exemple SELECT UserID IN (123, 456) FROM ...

Si le côté gauche est une colonne unique figurant dans l'index et que le côté droit est un ensemble de constantes, le système utilise l'index pour traiter la requête.

Le côté droit de l'opérateur peut être un ensemble d'expressions constantes, un ensemble de tuples, le nom d'une table de base de données ou une sous-requête SELECT entre parenthèses. La sous-requête peut spécifier plusieurs colonnes pour filtrer les tuples. Par exemple :

SELECT (CounterID, UserID) IN (SELECT CounterID, UserID FROM ...) FROM ....

Les colonnes situées à gauche et à droite de l'opérateur IN doivent posséder le même type.

L'opérateur IN et la sous-requête peuvent figurer dans n'importe quelle partie de la requête, y compris dans les fonctions agrégées et les fonctions lambda.

Traitement de NULL

L'opérateur IN suppose que le résultat d'une opération avec NULL est toujours égal à 0, que NULL figure droite ou à gauche de l'opérateur. Les valeurs NULL ne figurent dans aucun ensemble de données, ne correspondent pas entre elles et ne peuvent pas être comparées.

Le Symbole Astérisque (*)

Vous pouvez inclure un astérisque au lieu d'une expression dans n'importe quelle partie d'une requête. Lorsque la requête est analysée, l'astérisque se transforme en liste de toutes les colonnes de la table.

Vous pouvez utiliser un astérisque dans les cas suivants :

  • Pour créer un vidage de table.
  • Pour les tables qui ne contiennent que quelques colonnes. En cas de forte filtration sur un petit nombre de colonnes, utilisez PREWHERE.
  • Pour obtenir les informations concernant les colonnes d'une table. Dans ce cas, définissez LIMIT 1. Nous vous recommandons d'utiliser la requête DESC TABLE.
  • Dans les sous-requêtes, car les colonnes qui ne sont pas nécessaires à la requête externe sont exclues des sous-requêtes.

Dans tous les autres cas, pour éviter des problèmes de performance, nous vous déconseillons d'utiliser l'astérisque.

Rubriques Connexes

Syntaxe SQL de Requête Avancée

Fonctions d'Agrégation

Types de Données Pris en Charge

Fonctions Régulières