page de test Ocient

89 min

Le prend en charge les requêtes utilisant la syntaxe SQL conforme aux normes ANSI SQL.

Syntaxe SQL Ocient

@virtual

Ce bloc de code montre la syntaxe générale pour effectuer des requêtes SQL dans ainsi que l’ordre dans lequel les commandes doivent être placées.

Pour obtenir des descriptions et la syntaxe spécifiques des commandes, consultez les sections respectives des instructions SQL sur cette page.

Syntaxe

[ WITH ... ]
SELECT ...
    [ EXCEPT(...) ]
[ FROM ...
    [ JOIN ... ] ]   
[ WHERE ... ]
[ GROUP BY ... 
    [ HAVING ... ] ]
[ ORDER BY ... ] 
[ LIMIT ... ]
[ OFFSET ... ] 
[ INTERSECT ... ]
[ EXCEPT ... ]
[ UNION ... ] ]         
[ USING ... ]
[ TRACE ... ] 
[ TAG ... ]

Schéma par défaut

Ocient identifie chaque table à l’aide d’une base de données et d’un schéma. Par exemple, le chemin pleinement qualifié vers la table films est cinema.adventure.movies, où cinéma est la base de données et aventure est le schéma.

Lorsque vous ne qualifiez pas entièrement un nom de table, le système Ocient utilise un schéma par défaut. Lorsque vous ouvrez une session dans le système pour la première fois, le schéma par défaut correspond à votre nom d’utilisateur pleinement qualifié. Vous pouvez modifier le schéma par défaut à l’aide de la commande DÉFINIR LE SCHÉMA .

Référence des instructions de requête SQL

Ocient prend en charge les instructions SQL suivantes.

WITH

Attribue un nom à une expression de table commune, permettant à une requête auxiliaire d’être utilisée dans la requête principale. Cela est utile pour décomposer des requêtes complexes en parties plus petites.

Syntaxe

WITH 
    <cte_name> [ ( <cte_column> [ ,... ] ) ] 
    AS ( <sub_query> )
<select_query>

Paramètres

Paramètre	Description
<cte_name>	Nom de l’expression de table commune remplie avec l’ensemble de résultats de l’instruction sub_query .
<cte_column>	Facultatif. Il s’agit d’une liste de noms de colonnes pour les expressions de table communes remplies avec l’ensemble de résultats sub_query. Si aucun nom de colonne n’est fourni, les noms de colonnes sont les mêmes que ceux de la table référencée dans l’instruction sub_query .
<sub_query>	Une requête auxiliaire qui collecte des données pour une expression de table commune. sub_query peut utiliser des commandes de requête régulières, y compris ORDER BY, LIMIT, OFFSET, UNION, INTERSECT, EXCEPT, WHERE, GROUP BY et HAVING. Consultez les sections de référence respectives des instructions SQL pour connaître les règles d’utilisation.
<select_query>	La requête SELECT principale. Notez que l’instruction DE dans la requête principale SELECT doit également inclure cte_name si la requête utilise ses valeurs.

Exemple

Dans cet exemple, la sous-requête calcule le budget moyen pour toutes les lignes de la table movies . La requête principale utilise cette moyenne pour trouver tous les films qui ont dépensé davantage.

WITH avg_budget_table (average_budget) AS (
    SELECT AVG(budget)
    FROM movies
)
SELECT title,
    budget,
    revenue
FROM movies,
    avg_budget_table
WHERE budget > avg_budget_table.average_budget;

Résultat

titre	budget	revenu
CGI Why	237000000	2787965087
Titania	200000000	1845034188
Véhicule de marchandise 5	200000000	1066969703
Le Tentpole	220000000	1519557910
Pirates de Palm Springs	140000000	655011224
Espion 16	200000000	1108561013
Glacial	150000000	1274219009
Furie 7	190000000	1506249360
Superhéros 23	250000000	1084939099
Monde Triassique	150000000	1513528810
Chef de fer 3	200000000	1215439994
Le dernier aviateur	150000000	318502923

SELECT

Initie une instruction query statement ou une clause de sous-requête dans d’autres instructions.

Vous pouvez interroger les données des tables pour lesquelles vous disposez du privilège SELECT.

Pour obtenir des informations sur l’utilisation de SELECT comme sous-requête pour filtrer ou trier les résultats, consultez les sections OÙ et AYANT .

Pour obtenir des informations sur l’utilisation de SELECT comme sous-requête pour une expression de table commune, consultez la section AVEC .

Syntaxe

SELECT [ ALL | DISTINCT ] 
    [ * [ EXCEPT ( column_name [ , ... ] ) ] 
    | <select_list_entry> [ , ... ] ]
    [ <from_clause> ]

Paramètres

Paramètre	Description
TOUT	SELECT et TOUT SÉLECTIONNER sont identiques. Renvoie toutes les lignes de données valides de la base de données qui répondent aux critères de votre requête.
DISTINCT	SELECT DISTINCT renvoie uniquement des lignes uniques qui ne correspondent pas à d’autres lignes selon les critères de votre requête.
*	Renvoie toutes les colonnes des tables spécifiées dans l’ensemble de résultats de la requête.
SAUF	Lorsqu’il est utilisé avec *, SAUF permet d’exclure des colonnes spécifiques des résultats de la requête.
nom_de_colonne	Nom d’une ou de plusieurs colonnes de la table spécifiée que vous souhaitez exclure (à l’aide de SAUF) des résultats de votre requête.

<select_list_entry>

L’élément select_list_entry définit une colonne ou une expression à inclure dans l’ensemble de résultats de votre requête.

Syntaxe

<select_list_entry> ::= 
    column_name | expression [ AS new_name ]

Paramètres

Paramètre	Description
nom_de_colonne	Le nom d’une ou de plusieurs colonnes de la table spécifiée que vous souhaitez inclure dans les résultats de votre requête.
expression	Une ou plusieurs expressions que vous souhaitez inclure dans les résultats de votre requête. Les expressions peuvent être n’importe quelle combinaison de valeurs littérales, de noms de colonnes, d’expressions arithmétiques, de parenthèses et d’appels de fonction.
nouveau_nom	Un alias, traité comme un identifiant, pour un nom alternatif de la colonne ou des résultats de l’expression.

<clause_from>

Pour obtenir des informations sur <from_clause>, consultez la documentation DE.

Exemples

Utilisation de SELECT *

Cet exemple utilise SELECT * pour renvoyer toutes les colonnes de la table movies.

SELECT * FROM movies LIMIT 5;

Sortie

movie_id	title	budget	popularity	release_date	revenue	runtime	movie_status	vote_average	vote_count
211672	Minnows	74000000	875.581305	2015-06-17	1156730962	91	Sorti	6.40	4571
24	Billy the Killy	30000000	79.754966	2003-10-10	180949000	111	Sorti	7.70	4949
19995	CGI Why	237000000	150.437577	2009-12-10	2787965087	162	Publié	7.20	11800
37724	Spyman 16	200000000	93.004993	2012-10-25	1108561013	143	Publié	6.90	7604
24428	The Tentpole	220000000	144.448633	2012-04-25	1519557910	143	Publié	7.40	11776

Utilisation de SELECT * EXCEPT

Cet exemple utilise SELECT * EXCEPT pour exclure certaines colonnes du jeu de résultats.

SELECT *
EXCEPT (movie_id, runtime, vote_average, vote_count)
FROM movies
LIMIT 5;

Résultat

title	budget	release_date	revenue
Swords & Scabbards	94000000	2003-12-01	1118888979
Billy the Killy	30000000	2003-10-10	180949000
Merchandise Vehicle 5	200000000	2010-06-16	1066969703
CGI Why	237000000	2009-12-10	2787965087
Space Odyssey 6000	10500000	1968-04-10	68700000

Utilisation des alias de colonnes latéraux

Les requêtes Ocient SQL prennent en charge les alias de colonnes latéraux, ce qui signifie que vous pouvez réutiliser immédiatement des alias pour des calculs dans la même requête comme nouvelles entrées. Par conséquent, vous pouvez simplifier les requêtes qui nécessitent normalement des sous-requêtes et des expressions de table communes.

Ces exemples utilisent la table produits avec ces colonnes :

product_id — Identifiant du produit sous forme d’entier

product_name — Nom du produit sous forme de chaîne

prix — Prix sous forme de nombre à virgule flottante

Créez cette table à l’aide de l’instruction SQL CRÉER UNE TABLE.

CREATE TABLE products (
    product_id INT,
    product_name VARCHAR(100),
    price DECIMAL(10, 2)
    );

Insérez quatre enregistrements dans la table produits.

INSERT INTO products (product_id, product_name, price) VALUES
    (1, 'Laptop', 1000.00),
    (2, 'Tablet', 500.00),
    (3, 'Smartphone', 800.00),
    (4, 'Monitor', 300.00);

Créez une requête pour déterminer les prix après réductions et taxes en utilisant une sous-requête d’expression de table commune Prix réduits. Utilisez le mot-clé AVEC pour créer la sous-requête.

WITH DiscountedPrices AS (
    SELECT 
        product_id,
        product_name,
        price,
        price * 0.90 AS discounted_price,
        price * 0.90 * 1.05 AS total_price_after_tax
    FROM 
        products
)
SELECT 
    product_id,
    product_name,
    price,
    discounted_price,
    total_price_after_tax
FROM 
    DiscountedPrices;

Les alias latéraux permettent de regrouper les mêmes calculs dans une seule requête.

Cette requête plus simple est essentiellement identique à l’exemple plus long d’expression de table commune, mais la logique est condensée parce que vous pouvez référencer immédiatement l’alias prix_remisé pour calculer la valeur prix_total_après_taxe dans la même requête.

SELECT 
    product_id,
    product_name,
    price,
    price * 0.90 AS discounted_price,
    discounted_price * 1.05 AS total_price_after_tax
FROM 
    products;

FROM

Spécifie la table ou vue à utiliser dans une instruction SELECT .

Syntaxe

<select_clause> FROM 
    { table_name | ( <sub_query> ) } [ ,... ]
    [ <join_clause> [ ,... ] ]

Paramètres

Paramètre	Description
<select_clause>	Une instruction de requête utilisant l’instruction SQL SELECT . Pour plus de détails, consultez la section SELECT .
nom_de_table	Les noms d’une ou plusieurs tables ou vues que vous souhaitez interroger. Si vous spécifiez plusieurs tables dans la liste DE , séparées par des virgules, l’effet est le même que si vous effectuiez explicitement un JOINTURE CROISÉE sur toutes ces sources.
<sub_query>	Une ou plusieurs sous-requêtes utilisant l’instruction SQL SELECT . Une sous-requête génère une table à partir de laquelle la requête clause_select référence des données. Chaque sous-requête doit être placée entre parenthèses avec un nom de corrélation facultatif. Pour plus de détails, consultez la section SELECT .
<join_clause>	Une clause REJOINDRE utilisée pour récupérer des données à partir de deux tables ou plus pour votre requête. Pour plus de détails, consultez la section REJOINDRE .

JOIN

Combine des lignes provenant de plusieurs tables afin qu’elles puissent être accessibles par une requête.

Syntaxe

<select_query> 
    FROM <table_reference1> <join_operation> <table_reference2> 
        ON table1_column <boolean_operator> table2_column

Paramètre

Paramètre	Description
<select_query>	Une requête SELECT valide. Pour plus de détails, consultez SELECT.
<table_reference1>	Soit un nom de table ou une requête SELECT complète entre parenthèses table_reference1 a priorité pour le retour des lignes pour JOINTURE EXTERNE GAUCHE, SEMI JOIN, et ANTI JOIN. Pour les règles spécifiques, consultez Types d’opérations JOIN.
<table_reference2>	Soit un nom de table ou une fonction SELECT complète entre parenthèses. table_reference2 a priorité pour le retour des lignes pour JOINTURE EXTERNE DROITE. Pour les règles spécifiques, consultez Types d’opérations JOIN.
table1_column	Une colonne provenant de référence_du_tableau L’opération REJOINDRE utilise cette colonne pour faire correspondre les lignes avec table2_column afin de combiner les données pour l’ensemble de résultats.
<boolean_operator>	Les conditions de jointure peuvent utiliser toute expression booléenne, y compris =, !=, <, >, =>, et <=
table2_column	Une colonne provenant de référence_du_tableau non utilisée pour table1_column L’opération REJOINDRE utilise cette colonne pour faire correspondre les lignes en fonction de table1_column afin de combiner les données pour l’ensemble de résultats.

Types d’opérations JOIN ( <join_operation> )

Ocient prend en charge les types suivants d’opérations REJOINDRE.

Syntaxe

<join_operation> ::=   
    { INNER JOIN
    | LEFT [ OUTER ] JOIN
    | RIGHT [ OUTER ] JOIN
    | FULL [ OUTER ] JOIN
    | CROSS JOIN
    | SEMI JOIN 
    | ANTI JOIN }

Descriptions des types JOIN

Type de JOIN	Description
JOINTURE INTERNE	Retourne toutes les lignes qui existent dans les deux tables. Ce type de jointure est le type de jointure par défaut.
JOINTURE EXTERNE GAUCHE	Retourne toutes les lignes de la première table, qu’il y ait ou non des lignes correspondantes dans la deuxième table. LEFT JOIN effectue la même opération que JOINTURE EXTERNE GAUCHE.
JOINTURE EXTERNE DROITE	Retourne toutes les lignes de la deuxième table, qu’il y ait ou non des lignes correspondantes dans la première table. RIGHT JOIN effectue la même opération que JOINTURE EXTERNE DROITE.
FULL OUTER JOIN	Retourne toutes les lignes correspondantes et non correspondantes. FULL JOIN effectue la même opération que FULL OUTER JOIN.
JOINTURE CROISÉE	Retourne le produit cartésien des tables jointes. Chaque ligne de la première table est jointe à toutes les lignes de la deuxième table. L’ensemble de résultats contient le nombre de lignes de la première table multiplié par le nombre de lignes de la deuxième table.
SEMI JOIN	Retourne les lignes de la première table qui ont au moins une correspondance dans la deuxième table. Aucune colonne de la deuxième table n’est disponible dans la requête.
ANTI JOIN	Retourne les lignes de la première table qui n’ont aucune correspondance dans la deuxième table. Aucune colonne de la deuxième table n’est disponible dans la requête.

Par défaut, les instructions REJOINDRE qui impliquent des sous-requêtes peuvent fonctionner latéralement si nécessaire. Ce comportement permet aux sous-requêtes de référencer les colonnes jointes des éléments précédents inclus dans la clause DE.

Par exemple, les deux parties de cette opération de jointure utilisent des sous-requêtes qui référencent la table x. Le mot-clé LATÉRAL est facultatif; l’opération de jointure agit de la même façon, qu’il soit inclus ou non.

SELECT * FROM ( SELECT 1 AS cx1, 2 AS cx2) AS x INNER JOIN LATERAL ( SELECT x.cx1 AS cy1, x.cx2 AS cy2) AS y ON x.cx1 = y.cy1;

Les jointures latérales sont principalement utiles lorsqu’une colonne référencée de façon croisée est nécessaire pour calculer les lignes à joindre. Une application courante consiste à fournir une valeur d’argument pour une fonction retournant un ensemble.

Exemples

Ces exemples joignent deux tables :

jeux — Une table des titres de jeux vidéo et de leurs genre_ids. Notez que certains jeux ont une valeur NULL assignée à leur genre_id.

nom_du_jeu	id_du_genre
Bataille stellaire 6000	9
Simulateur de nain	NULL
Futbol 2002	11
Attaque spatiale!	9
Fou fantastique	8
Blasto l'écureuil	5
Quête du camionneur	7
Bloquer, empiler et pleurer!	6
Journée de basketball	11
Mutant pizza	1
Plombier italien	5
Zombies!	1
Ninjas de l'espace	12
Maire de la lune	10
Héros des feuilles de calcul	NULL
Magnat du zoom	12
Braconnier de porche	6

genre — Une table des genres de jeux vidéo, qui sont identifiés par des ID.

genre_name	id
Course	7
Puzzle	6
Aventure	2
Simulation	10
Tir	9
Divers	4
Action	1
Sports	11
Jeu de rôle	8
Plateforme	5
Stratégie	12
Combat	3

INNER JOIN

Cet exemple utilise une opération JOINTURE INTERNE pour capturer uniquement les lignes qui existent dans les deux tables. Les jeux avec des valeurs NULL pour leur genre_id sont éliminés de l’ensemble de résultats.

SELECT game_name,
    genre_name
FROM video_games.game
    INNER JOIN video_games.genre ON game.genre_id = genre.id;

Résultat

nom_du_jeu	nom_du_genre
Fantasy Fool	Jeu de rôle
Blasto the Squirrel	Plateforme
Italian Plumber	Plateforme
Porch Poacher	Puzzle
Space Ninjas	Stratégie
Basketball Day	Sports
2002 Futbol	Sports
Moon Mayor	Simulation
Block, Stack, and Cry!	Puzzle
Zombies!	Action
Pizza Mutant	Action
Space Attack!	Jeu de tir
Trucker Quest	Course
Zoom Tycoon	Stratégie

LEFT OUTER JOIN

Cet exemple utilise une opération JOINTURE EXTERNE GAUCHE pour capturer toutes les lignes de la table de gauche (game), même si elles n’ont aucune ligne correspondante dans la table de droite (genre).

SELECT game_name,
    genre_name
FROM video_games.game
    LEFT OUTER JOIN video_games.genre ON game.genre_id = genre.id;

Résultat

game_name	genre_name
Fantasy Fool	Jeu de rôle
Space Ninjas	Stratégie
Zoom Tycoon	Stratégie
Zombies!	Action
Pizza Mutant	Action
Trucker Quest	Course
Blasto the Squirrel	Plateforme
2002 Futbol	Sports
Basketball Day	Sports
Italian Plumber	Plateforme
Block, Stack, and Cry!	Puzzle
Star Battle 6000	Shooter
Dwarf Simulator	NULL
Moon Mayor	Simulation
Porch Poacher	Puzzle
Spreadsheet Hero	NULL
Space Attack!	Shooter

RIGHT OUTER JOIN

Cet exemple utilise une opération DROITE JOINTURE EXTERNE pour capturer toutes les lignes de la table de droite (genre), même si elles n’ont aucune ligne correspondante dans la table de gauche (game).

SELECT game_name,
    genre_name
FROM video_games.game
    RIGHT OUTER JOIN video_games.genre ON game.genre_id = genre.id;

Résultat

nom_du_jeu	nom_du_genre
NULL	Aventure
Trucker Quest	Course
Pizza Mutant	Action
Moon Mayor	Simulation
Fantasy Fool	Jeu de rôle
Space Attack!	Jeu de tir
NULL	Divers
Star Battle 6000	Jeu de tir
Space Ninjas	Stratégie
Porch Poacher	Réflexion
Block, Stack, and Cry!	Réflexion
Blasto the Squirrel	Plateforme
Italian Plumber	Plateforme
Zoom Tycoon	Stratégie
NULL	Combat
Zombies!	Action
2002 Futbol	Sports
Basketball Day	Sports

JOINTURE EXTERNE COMPLÈTE

Cet exemple utilise une opération FULL OUTER JOIN pour capturer toutes les lignes des deux tables, même si elles ne correspondent pas.

SELECT game_name,
    genre_name
FROM video_games.game
    FULL OUTER JOIN video_games.genre ON game.genre_id = genre.id;

Résultat

nom_du_jeu	nom_du_genre
Journée Basketball	Sports
2002 Futbol	Sports
Zombies!	Action
Blasto l'écureuil	Plateforme
Maire de la Lune	Simulation
Quête du camionneur	Course
NULL	Divers
Bataille stellaire 6000	Jeu de tir
Attaque spatiale!	Jeu de tir
Héros du tableur	NULL
NULL	Aventure
NULL	Combat
Plombier italien	Plateforme
Mutant pizza	Action
Simulateur de nain	NULL
Fou fantastique	Jeu de rôle
Bloquez, empilez et pleurez !	Puzzle
Ninjas de l’espace	Stratégie
Magnat du zoom	Stratégie
Voleur de porche	Puzzle

CROSS JOIN

Cet exemple utilise une opération JOINTURE CROISÉE pour capturer toutes les combinaisons possibles de lignes des deux tables, qu’elles correspondent ou non. Notez que contrairement aux autres opérations REJOINDRE, JOINTURE CROISÉE ne nécessite pas d’instruction ACTIVÉ.

SELECT game_name, 
    genre_name 
FROM video_games.genre 
    CROSS JOIN video_games.game;

Résultat

Comme l’ensemble de résultats pour cet exemple de CROSS JOIN contient plus de 200 lignes, les résultats sont abrégés.

nom_du_genre	id_du_genre
Héros du tableur	Jeu de rôle
Héros du tableur	Divers
Héros du tableur	Sports
Héros du tableur	Plateforme
Héros du tableur	Stratégie
Héros du tableur	Jeu de tir
Héros du tableur	Combat
Héros du tableur	Action
Héros du tableur	Simulation
Héros du tableur	Course
Héros du tableur	Puzzle
Héros du tableur	Aventure
Attaque spatiale!	Jeu de rôle
Attaque spatiale!	Divers
Attaque spatiale!	Sports
Attaque spatiale !	Plateforme
Attaque spatiale !	Stratégie
Attaque spatiale !	Jeu de tir
Attaque spatiale !	Combat
Attaque spatiale !	Action
Attaque spatiale !	Simulation
Attaque spatiale !	Course
Attaque spatiale !	Puzzle
Attaque spatiale !	Aventure
...	...

SEMI JOIN

Cet exemple utilise une opération SEMI JOIN pour récupérer les noms de genres ayant au moins une correspondance dans la table des jeux. Les lignes ne sont incluses qu’une seule fois, même s’il existe plusieurs correspondances.

SELECT genre_name, 
    id 
FROM video_games.genre 
    SEMI JOIN video_games.game ON genre.id = game.genre_id;

Résultat

genre_name	genre_id
Simulation	10
Shooter	9
Course	7
Stratégie	12
Puzzle	6
Plateforme	5
Action	1
Sports	11
Jeu de rôle	8

ANTI JOIN

Cet exemple utilise une opération ANTI JOIN pour récupérer toutes les lignes de la table game qui ne correspondent à aucune ligne de la table genre.

SELECT game_name
FROM video_games.game 
    ANTI JOIN video_games.genre ON game.genre_id = genre.id;

Résultat

game_name
Spreadsheet Hero
Dwarf Simulator

WHERE

Filtre les lignes en fonction d’une condition spécifiée.

Syntaxe

<select_query> 
    WHERE { column_name <filter_condition> filter_value | 
    [ NOT ] EXISTS ( <sub_query> ) }

Paramètres

Paramètre	Description
<select_query>	Une requête SELECT valide.
nom_de_colonne	Une colonne utilisée pour le regroupement qui est évaluée par la condition condition_de_filtre.
valeur_du_filtre	Une valeur utilisée pour évaluer le nom_de_colonne spécifié. Pour plus de détails, consultez la section <filter_condition>.
<sub_query>	Une sous-requête avec une condition de filtre qui suit la clause EXISTE. Pour plus de détails, consultez la section EXISTE.

<filter_condition>

Une combinaison logique de prédicats utilisée pour évaluer le nom_de_colonne référencé selon la valeur filter_value.

Syntaxe

<filter_condition> ::= 
  { =
    | ==
    | <>
    | !=
    | [ NOT ] EQUALS
    | <
    | <=
    | >
    | >=
    | [ NOT ] IN
    | [ NOT ] LIKE
    | [ NOT ] SIMILAR TO
    | BETWEEN
    | FOR SOME
    | FOR ALL
    | IS [ NOT ] NULL
    | IS [ NOT ] DISTINCT FROM 
  }

Définitions

Opérateur	Description	Exemple
=, ==, ÉGALE	Égal à.	Auteur = 'Alcott'
<>, !=	Différent de	Département <> 'Ventes'
>	Supérieur à	Date_d'embauche > '2012-01-31'
<	Inférieur à	Prime < 50000.00
>=	Supérieur ou égal à	Personnes à charge >= 2
<=	Inférieur ou égal à	Taux <= 0,05
[ PAS ] COMME	Commence par un modèle de caractères à faire correspondre. Le modèle est placé entre parenthèses et peut inclure les caractères génériques %, représentant zéro, un ou plusieurs caractères, et _ représentant un seul caractère. Pour avoir un caractère littéral % ou _ qui n’agit pas comme caractère générique du côté droit d’une expression LIKE ou NOT LIKE , placez une barre oblique inverse avant le caractère.	Nom_complet LIKE 'Will%'
[ PAS ] SIMILAIRE À	Pour des informations sur l’utilisation, consultez la section Opérateur SIMILAR TO.	'abc' SIMILAR TO 'abc'
ENTRE value1 ET value2	Nécessite deux valeurs. Le filtre est évalué à TRUE si la colonne spécifiée se trouve dans la plage entre les deux valeurs. ENTRE inclut les bornes. Les valeurs peuvent être des heures, des nombres ou des chaînes.	Ventes ENTRE 1000 ET 5000
FOR_SOME()	Évalue un tableau pour déterminer si au moins une valeur répond aux critères du filtre. Dans l’exemple, l’opérateur FOR_SOME() renverrait toutes les lignes de la colonne col_int_array où au moins une valeur est supérieure à 10. Pour plus de détails, consultez Filtres de tableau.	FOR_SOME(col_int_array) > 10 FOR_SOME(col_int_array) > 10
FOR_ALL()	Évalue toutes les valeurs d’un tableau pour déterminer si elles répondent toutes aux critères du filtre. Dans l’exemple, l’opérateur FOR_ALL() renverrait toutes les lignes de la colonne col_int_array où toutes les valeurs sont supérieures à 10. Pour plus de détails, consultez Filtres de tableau.	FOR_ALL(col_int_array) > 10 FOR_ALL(col_int_array) = 1
[ PAS ] DANS	Égal à l’une de plusieurs valeurs possibles	CodeDépartement IN (101, 103, 209)
IS [ NOT ] NULL	Comparer à NULL (données manquantes)	L’adresse N’EST PAS NULLE
IS [ NOT ] DISTINCT FROM	Compare l’égalité de deux expressions pour obtenir un résultat booléen, y compris les comparaisons impliquant des valeurs NULL. Cet opérateur garantit des comparaisons fiables dans les scénarios où les valeurs NULLNULL doivent être traitées comme des points de données significatifs. Normalement, NULL = NULL est évalué à faux parce que NULL représente une valeur inconnue. Cependant, l’instruction a N’EST PAS DISTINCT DE b traite NULL comme une valeur comparable et renvoie vrai lorsque les deux valeurs sont NULL ou lorsque a = b. Inversement, a est différent de b renvoie vrai si les valeurs sont différentes ou si une valeur est NULL tandis que l’autre n’est pas NULL.	La dette n’est pas DISTINCTE DES créances

EXISTS

Une clause EXISTE utilisée dans une instruction OÙ évalue si une sous-requête retourne des lignes.

Pour chaque ligne que la base de données calcule dans la requête externe, si la sous-requête retourne au moins une ligne, la clause EXISTS est évaluée à true. Dans ce cas, la requête externe retourne sa ligne.

Si la sous-requête retourne zéro ligne, la clause EXISTE est évaluée à faux, et la requête externe exclut ces lignes.

La clause N'EXISTE PAS effectue la logique booléenne opposée. Dans ce cas, la requête externe retourne des lignes uniquement lorsque la sous-requête ne comporte aucune correspondance.

Exemples

Ces exemples utilisent deux tables, une pour les départements de l’entreprise et l’autre pour les employés affectés à ces départements.

Créez la table départements pour les données des départements.

CREATE TABLE departments (
    id INT,
    name VARCHAR(50)
);

Créez la table employés pour les données des employés.

CREATE TABLE employees (
    id INT,
    name VARCHAR(50),
    department_id INT
);

Insérez des données de département pour trois départements, RH, IT, et Marketing, dans la table départements.

INSERT INTO departments (id, name) VALUES
    (1, 'HR'),
    (2, 'IT'),
    (3, 'Marketing');

Insérez des données d’employés pour quatre employés, Alice, Bob, Charlie, et David, dans la table employés.

INSERT INTO employees (id, name, department_id) VALUES
    (1, 'Alice', 1),
    (2, 'Bob', 2),
    (3, 'Charlie', 2),
    (4, 'David', 4);

Trouver les employés appartenant à un département existant

Cet exemple utilise une clause EXISTE pour trouver les noms de la table employés qui sont affectés à un département répertorié dans la table départements.

SELECT name
FROM employees AS e
WHERE EXISTS (
    SELECT *
    FROM departments AS d
    WHERE e.department_id = d.id
);

La requête retourne tous les employés sauf David, qui est affecté à un département qui n’existe pas dans la table départements.

Sortie

Bob 
Charlie
Alice

Trouver les départements qui ont des employés

Cette requête retourne les départements qui ont au moins un employé. La sous-requête utilise SELECT 1 pour vérifier si des lignes correspondantes existent dans la table employés. La sortie est la même si la requête utilise SELECT * à la place.

SELECT name 
FROM departments AS d
WHERE EXISTS (
    SELECT 1 
    FROM employees AS e 
    WHERE e.department_id = d.id
);

Les résultats de la requête excluent le département Marketing parce qu’aucun employé ne lui appartient.

Sortie

HR        
IT

Filtrer les départements en fonction d’une table non corrélée

Dans cet exemple, la requête externe filtre la table départements où id != 3 (en excluant le département Marketing). La sous-requête vérifie s’il existe au moins un employé avec un identifiant de département inférieur à 4.

La requête est non corrélée parce que la sous-requête ne référence pas la table départements.

SELECT * 
FROM departments d
WHERE d.id != 3 
AND EXISTS (
    SELECT * 
    FROM employees e 
    WHERE e.department_id < 4
);

Résultat

HR        
IT

Trouver des employés sans département valide

Cet exemple utilise une clause N'EXISTE PAS. L’exemple retourne uniquement les employés attribués à un identifiant de département department_id qui n’est pas répertorié dans la table départements.

SELECT name
FROM employees AS e
WHERE NOT EXISTS (
    SELECT *
    FROM departments AS d
    WHERE e.department_id = d.id
);

Résultat : David

Opérateur SIMILAR TO

SIMILAR TO est un mot-clé qui étend l’opérateur LIKE en ajoutant davantage de fonctionnalités pour le filtrage des correspondances, y compris plusieurs métacaractères utilisés dans les expressions régulières.

% et _ agissent tous deux comme des opérateurs génériques, mais les autres métacaractères pris en charge correspondent aux expressions régulières traditionnelles.

Syntaxe

WHERE string1 SIMILAR TO string2

Ce tableau décrit les métacaractères pris en charge par le mot-clé SIMILAR TO.

Métacaractère	Description
%	Joker répété, correspond à n’importe quels caractères zéro fois ou plus. Utilisation équivalente à LIKE.
_	Joker, correspond exactement à un caractère. Utilisation équivalente à LIKE.
\|	Alternative, signifiant l’une de deux possibilités (a\|b représente a ou b).
*	Répétition zéro fois ou plus.
+	Répétition une fois ou plus.
?	Répétition zéro ou une fois.
{m}	Répétition exactement m fois.
{m,n}	Répétition entre m et n fois (inclusivement).
{m,}	Répétition au moins m fois.
()	Regroupement logique.
[]	Classe de caractères, équivalente aux classes de caractères dans les expressions régulières. Exemple : [a-z] représente n’importe quelle lettre minuscule anglaise.
^	Ancre de début de ligne et négation dans les classes de caractères.
$	Ancre de fin de ligne.

SIMILAR TO prend également en charge l’échappement de ces métacaractères avec \ et certaines séquences d’échappement prises en charge par les langages de la famille C.

Métacaractère	Description
\a	Le caractère d’alerte/sonnerie.
\b	Le caractère de retour arrière.
\B	Un seul caractère \. Équivalent à \\.
\cX	Le caractère ayant les cinq bits de poids faible identiques à ceux de X avec tous les bits de poids fort à zéro.
\e	Le caractère de valeur numérique 27, Esc.
\f	Saut de page.
\n	Nouvelle ligne.
\r	Retour chariot.
	Tabulation horizontale.
\uwxyz
wxyz représente quatre chiffres hexadécimaux, incluant deux caractères : un avec la valeur numérique wx, et un avec la valeur numérique yz.
\xd....	d représente n'importe quel nombre de chiffres hexadécimaux. Si le nombre de chiffres est impair, un 0 est ajouté à gauche de la séquence. Les caractères numériques avec des valeurs représentées par chaque groupe de deux symboles de d.
\0	Caractère NULL 0.
\xy	xy sont des chiffres octaux qui représentent le caractère avec la valeur numérique xy.
\xyz	xyz sont des chiffres octaux qui représentent le caractère avec la valeur numérique xyz. Si x est supérieur ou égal à 4, la base de données renvoie deux caractères : la valeur numérique 1 et la valeur numérique des 8 bits inférieurs de xyz.
\d	Correspond à n'importe quel chiffre.
\s	Correspond à n'importe quel espace blanc.
\w	Correspond à n'importe quel caractère alphanumérique ou _.
\D	Correspond à n'importe quel caractère non numérique.
\S	Correspond à n'importe quel caractère autre qu'un espace blanc.
\W	Correspond à n'importe quel caractère non alphanumérique qui n'est pas non plus _.
\A	Le début d'une ligne. Équivalent à ^.
\m, \M, ou \y	La limite d'un mot. Équivalent à \b dans les expressions régulières normales.
\Y	Toute position qui n’est pas la limite d’un mot.
\Z	La fin d’une ligne. Équivalent à $ dans les expressions régulières normales.
\*	Le caractère étoile.
\+	Le caractère plus.
\?	Le caractère point d’interrogation.

La base de données ignore tout métacaractère \ qui ne précède pas un métacaractère (y compris \) ou une séquence d’échappement dans la table des métacaractères.

Les expressions non valides (quantificateurs sans préfixe, parenthèses non fermées, etc.) entraînent des erreurs de requête.

La base de données ne reconnaît pas le caractère . comme un métacaractère, contrairement au comportement des expressions régulières traditionnelles.

La base de données applique les métacaractères d’échappement qui s’appliquent aux littéraux de chaîne. Pour faire correspondre une chaîne contenant un seul '\', vous devrez peut-être utiliser '\\\\'.

Exemples

'abc' SIMILAR TO 'abc'          true
'abc' SIMILAR TO 'a'            false
'abc' SIMILAR TO '%(b|d)%'      true
'abc' SIMILAR TO '(b|c)%'       false
'-abc-' SIMILAR TO '%\mabc\M%'  true
'xabcy' SIMILAR TO '%\mabc\M%'  false

Filtres de tableau

Une expression de filtre peut utiliser les fonctions FOR_SOME() et FOR_ALL() pour appliquer un prédicat à toutes les valeurs d’un tableau d’entrée.

Les fonctions de filtre de tableau suivent les règles suivantes :

Elles peuvent uniquement évaluer des types tableau.

Elles peuvent se trouver à gauche ou à droite d’une expression de comparaison booléenne, mais pas des deux côtés en même temps.

Elles doivent utiliser directement un opérateur de comparaison booléenne.

Elles ne peuvent pas utiliser les mots-clés SQL QUELQUE et TOUT .

Comportement du filtre avec des tableaux vides

Les fonctions de filtre de tableau ont un comportement unique lors de l’évaluation de tableaux vides.

FOR_ALL() évalue un tableau vide comme étant VRAI.

FOR_SOME() évalue un tableau vide comme étant FAUX.

Si des tableaux vides doivent être évalués pour obtenir un résultat différent, vous pouvez utiliser la fonction LONGUEUR_TABLEAU pour spécifier une longueur minimale de tableau. Par exemple, cette instruction évaluerait un tableau comme étant VRAI uniquement s’il n’est pas vide et que toutes les valeurs correspondent à %ocient% :

ARRAY_LENGTH(array_col) > 0 AND FOR_ALL(array_col) LIKE '%ocient%

Pour plus de détails sur les fonctions de tableau, consultez la page Fonctions et opérateurs de tableau.

Comportement du filtre avec des lignes NULL

Le filtrage avec des fonctions de tableau peut produire des résultats différents selon que la ligne du tableau est NULL ou que les valeurs contenues dans le tableau sont NULL.

Si FOR_SOME() ou FOR_ALL() évaluent une ligne NULL (la ligne elle-même est NULL, et non le fait que le tableau contienne des valeurs NULL), le résultat est alors toujours FAUX.

Pour vérifier si un tableau contient des valeurs NULL, vous devez utiliser l’opérateur EST NUL . Par exemple :

FOR_SOME(array_col) IS NULL

Les opérateurs de comparaison de tableau, tels que @>, <@, et && ne respectent pas la logique booléenne pour les valeurs NULL. Pour plus de détails, consultez la page Fonctions et opérateurs de tableau .

GROUP BY

Regroupe les lignes ayant les mêmes valeurs dans des lignes récapitulatives, selon une fonction d’agrégation spécifiée.

Syntaxe

SELECT <select_list_clause> FROM table_name 
    GROUP BY { column_name | expression | integer } [ , ... ]
    [ HAVING <filter_condition> ]

Paramètres

Paramètre	Description
<select_list_clause>	Une liste d’une ou plusieurs colonnes pour la requête SELECT. Pour utiliser GROUPE PAR afin de résumer l’ensemble de résultats de la requête, au moins une des colonnes dans liste_des_colonnes doit inclure une fonction d’agrégation, telle que SOMME(), COUNT(), ou MAX(). Pour obtenir une liste des fonctions prises en charge, consultez la page Fonctions d’agrégation.
nom_de_table	La table à utiliser pour la requête.
nom_de_colonne	Le nom d’une ou plusieurs colonnes à utiliser pour regrouper l’ensemble de résultats. Si vous spécifiez plusieurs colonnes, l’ensemble de résultats est regroupé selon chaque combinaison unique de valeurs provenant des colonnes.
expression	Toute combinaison de valeurs littérales, de noms de colonnes, d’expressions arithmétiques, de parenthèses et d’appels de fonction.
entier	Un entier représentant la position des colonnes référencées dans liste_des_colonnes. La première position commence à 1.
<filter_condition>	Une clause AYANT qui filtre les groupes agrégés selon une condition spécifiée. Pour plus de détails, consultez la section <filter_condition>.

Exemple

Cet exemple utilise une base de données de films pour calculer le montant total dépensé pour la production de films par année.

SELECT YEAR(release_date),
    SUM(budget)
FROM movies
GROUP BY 1
ORDER BY 1 ASC;

Sortie

year(release_date)	sum(budget)
1968	10500000
1979	31500000
1981	18000000
1982	28000000
1992	14000000
1997	200000000
2003	264000000
2009	237000000
2010	350000000
2012	670000000
2013	350000000
2015	414000000

HAVING

Filtre les lignes agrégées en fonction d’une condition spécifiée.

AYANT fonctionne dans une instruction GROUPE PAR en définissant un filtre pour les lignes à agréger et à regrouper.

Pour plus d’informations sur l’utilisation de GROUPE PAR dans une instruction de requête, consultez GROUPE PAR.

Syntaxe

GROUP BY column_name HAVING <filter_condition>

Paramètres

Paramètre	Description
nom_de_colonne	Une colonne utilisée pour le regroupement qui est évaluée par la condition_de_filtre.
<filter_condition>	Une combinaison logique de prédicats booléens. Pour obtenir des informations sur les prédicats logiques pris en charge, consultez <filter_condition>.

Exemple

Cet exemple calcule le montant total dépensé pour la production de films par année. La clause AYANT filtre toutes les lignes qui n'ont pas une somme d'au moins 100 millions $.

SELECT YEAR(release_date),
    SUM(budget)
FROM movies
GROUP BY 1
HAVING SUM(budget) > 100000000
ORDER BY 1 ASC;

Résultat

year(release_date)	sum(budget)
1997	200000000
2003	264000000
2009	237000000
2010	350000000
2012	670000000
2013	350000000
2015	414000000

ORDER BY

Trie le jeu de résultats par ordre croissant ou décroissant selon une ou plusieurs colonnes spécifiées.

Si vous spécifiez plusieurs colonnes, elles sont triées hiérarchiquement de gauche à droite.

Syntaxe

ORDER BY { column_position | column_name } [ ASC | DESC ] 
    [ NULLS FIRST | NULLS LAST ] [ , ... ]

Paramètres

Paramètre	Type de données	Description
column_position	Entier	La position d’une colonne à utiliser pour le tri TRIER PAR. Les positions des colonnes commencent à 1.
nom_de_colonne	Chaîne	Le nom d’une colonne à utiliser pour le tri TRIER PAR.
ASC \| DESC	Chaîne	Facultatif. Indique si la colonne doit être triée en ordre croissant (ASC) ou décroissant (DESC). Si non spécifié, la valeur par défaut est ASC.
NULLS FIRST \| NULLS LAST	Chaîne	Facultatif. NULLS FIRST signifie que les valeurs nulles sont placées au début du jeu de résultats. NULLS LAST signifie que les valeurs nulles sont placées à la fin du jeu de résultats. Si non spécifié, la valeur par défaut est NULLS FIRST.

Exemple

Dans cet exemple, l’instruction TRIER PAR trie les films du plus récent au plus ancien.

SELECT release_date, title 
FROM movies 
ORDER BY release_date DESC;

Résultat

date_de_sortie	titre
2015-06-17	Minnows
2015-06-09	Monde triasique
2015-04-01	Furie 7
2013-11-27	Glacial
2013-04-18	Iron Chef 3
2012-10-25	Espionman 16
2012-07-16	Superhéros 23
2012-04-25	Le Tentpole
2010-06-30	Le dernier aviateur
2010-06-16	Véhicule de marchandises 5
2009-12-10	Pourquoi CGI
2003-12-01	Épées et fourreaux
2003-10-10	Billy le Killy
2003-07-09	Pirates de Palm Springs
1997-11-18	Titania
1992-08-07	Bang Bang Western
1982-06-25	Blade Walker
1981-06-12	Les aventuriers du temple de la jungle
1979-08-15	Apocalypse jamais
1968-04-10	Odyssée de l’espace 6000

LIMIT

Limite le nombre de lignes retournées par une requête à une quantité spécifiée.

Les lignes retournées sont non déterministes à moins que vous n’utilisiez une clause TRIER PAR.

Syntaxe

<select_query> LIMIT limit_number

Paramètres

Paramètre	Description
<select_query>	Une requête SELECT valide.
limit_number	Le nombre de lignes à retourner à partir de la requête, spécifié comme un entier positif ou toute expression scalaire constante qui s’évalue à un entier positif.

Exemples

Limiter les lignes retournées à l’aide d’un nombre

Cet exemple utilise LIMITE pour restreindre le nombre de titres de films retournés à seulement trois.

SELECT title FROM movies LIMIT 3;

Sortie

Minnows
CGI Why
Billy the Killy

Limiter les lignes retournées à l’aide d’une expression

L’instruction SQL LIMITE peut également accepter des expressions. Cette requête utilise l’expression 1+2 avec la table sys.dummy pour créer une table de trois entiers incrémentiels. Pour plus de détails, consultez Générer des tables à l’aide de sys.dummy.

SELECT c1 FROM sys.dummy10 LIMIT 1+2;

Sortie

1
2
3

OFFSET

Ignore un nombre spécifié de lignes du jeu de résultats.

Les lignes retournées sont non déterministes à moins que vous n’utilisiez une clause TRIER PAR.

Syntaxe

<select_query> OFFSET offset_number

Paramètres

Paramètre	Description
<select_query>	Une requête SELECT valide.
offset_number	Le nombre de lignes à ignorer lors du retour des résultats de la requête, spécifié comme un entier positif ou toute expression scalaire constante qui s’évalue à un entier positif.

Exemples

Ignorer des lignes du jeu de résultats à l’aide d’un nombre

Dans cet exemple, l’instruction TRIER PAR trie les résultats par ordre chronologique. Par conséquent, la clause DÉCALAGE supprime les six films les plus anciens du jeu de résultats.

SELECT release_date,
    title
FROM movies
ORDER BY release_date OFFSET 6;

Résultat

release_date	title
2003-07-09	Pirates of Palm Springs
2003-10-10	Billy the Killy
2003-12-01	Swords & Scabbards
2009-12-10	CGI Why
2010-06-16	Merchandise Vehicle 5
2010-06-30	The Last Airman
2012-04-25	The Tentpole
2012-07-16	Superhero 23
2012-10-25	Spyman 16
2013-04-18	Iron Chef 3
2013-11-27	Frigid
2015-04-01	Fury 7
2015-06-09	Triassic World
2015-06-17	Minnows

Ignorer des lignes du jeu de résultats à l’aide d’une expression

L’instruction SQL DÉCALAGE peut également accepter des expressions. Cette requête utilise l’expression 3+4 avec la table sys.dummy pour créer une colonne d’entiers incrémentiels en ignorant les sept premières lignes sur 10. Pour plus de détails, consultez Générer des tables à l’aide de sys.dummy.

SELECT c1 FROM sys.dummy10 OFFSET 3+4;

Résultat

8
9
10

INTERSECT

Retourne toutes les lignes qui correspondent entre deux requêtes SELECT distinctes. Pour utiliser INTERSECT, les deux requêtes doivent être compatibles, ce qui signifie qu’elles doivent retourner le même nombre de colonnes et avoir des types de données similaires.

Par défaut, l’instruction SQL élimine les lignes dupliquées sauf si la requête inclut le mot-clé facultatif TOUT. L’utilisation du mot-clé DISTINCT équivaut à ce comportement par défaut.

Syntaxe

<select_query1> INTERSECT [ ALL | DISTINCT ] <select_query2>

Paramètres

Paramètre	Description
<select_query1>	Une requête SELECT valide.
<select_query2>	Une requête SELECT valide.

Exemple

Cet exemple comporte deux requêtes SELECT avec une instruction INTERSECT. La requête complète récupère les films ayant eu un budget d’au moins 200 millions de dollars, mais ayant également généré plus d’un milliard de dollars de revenus.

SELECT *
FROM movies
WHERE revenue > 1000000000
INTERSECT
SELECT *
FROM movies
WHERE budget > 20000000;

Résultat

movie_id	title	budget	popularity	release_date	revenue	runtime	movie_status	vote_average	vote_count
597	Titania	200000000	100.025899	1997-11-18	1845034188	194	Sorti	7.5	7562
19995	CGI Why	237000000	150.437577	2009-12-10	2787965087	162	Sorti	7.2	11800
49026	Superhéros 23	250000000	112.31295	2012-07-16	1084939099	165	Publié	7.6	9106
10193	Véhicule de marchandise 5	200000000	59.995418	2010-06-16	1066969703	103	Publié	7.6	4597
211672	Ménés	74000000	875.581305	2015-06-17	1156730962	91	Publié	6.4	4571
122	Épées et fourreaux	94000000	123.630332	2003-12-01	1118888979	201	Publié	8.1	8064
37724	Spyman 16	200000000	93.004993	2012-10-25	1108561013	143	Publié	6.9	7604
109445	Glacial	150000000	165.125366	2013-11-27	1274219009	102	Publié	7.3	5295
168259	Furious 7	190000000	102.322217	2015-04-01	1506249360	137	Sorti	7.3	4176
68721	Iron Chef 3	200000000	77.68208	2013-04-18	1215439994	130	Sorti	6.8	8806
135397	Triassic World	150000000	418.708552	2015-06-09	1513528810	124	Sorti	6.5	8662
24428	Le chapiteau	220000000	144.448633	2012-04-25	1519557910	143	Publié	7.4	11776

EXCEPT

Le SAUF mot-clé retourne l’ensemble de résultats d’une première requête SELECT moins toute ligne correspondante d’une deuxième requête SELECT.

SAUF exige que les deux requêtes soient compatibles, ce qui signifie qu’elles doivent retourner le même nombre de colonnes et avoir des types de données similaires. Par défaut, l’ensemble de résultats élimine les lignes en double, sauf si la requête inclut le mot-clé facultatif TOUT. L’utilisation du mot-clé DISTINCT correspond à ce comportement par défaut.

Le SAUF mot-clé peut également être utilisé pour exclure des colonnes spécifiques d’une requête SELECT *. Pour obtenir des informations sur cette utilisation alternative, consultez la syntaxe et l’exemple de SELECT .

Syntaxe

<select_query1> EXCEPT [ ALL | DISTINCT ] <select_query2>

Paramètres

Paramètre	Description
<select_query1>	Une requête SELECT valide qui est comparée à select_query2. Les résultats d’une instruction EXCEPT sont les lignes dans select_query1 qui ne correspondent à aucune ligne dans select_query2.
<select_query2>	Une requête SELECT valide qui est comparée à select_query1.

Exemple

Dans cet exemple, la première instruction SELECT interroge toutes les lignes de la table movies. La clause SAUF et la deuxième instruction SELECT éliminent des résultats toutes les lignes contenant des films dont le budget était supérieur à 20000000.

SELECT *
FROM movies
EXCEPT
SELECT *
FROM movies
WHERE budget > 20000000;

Résultat

titre	budget	popularité	date_de_sortie	revenus	durée	statut_du_film	moyenne_des_votes	nombre_de_votes
Bang Bang Western	14000000	37.380435	1992-08-07	159157447	131	Sorti	7.7	1113
Space Odyssey 6000	10500000	86.201184	1968-04-10	68700000	149	Sorti	7.9	2998
Raiders of the Jungle Temple	18000000	68.159596	1981-06-12	389925971	115	Sorti	7.7	3854

UNION

Retourne l’ensemble de résultats combiné de deux requêtes SELECT ou plus.

Par défaut, UNION élimine les lignes dupliquées de l’ensemble de résultats sauf si vous spécifiez le mot-clé TOUT. L’utilisation du mot-clé DISTINCT correspond à ce comportement par défaut.

Syntaxe

<select_query1> UNION [ ALL | DISTINCT ] <select_query2> [ ... ]

Paramètres

Paramètre	Type de données	Description
select_query1	String	Une requête SELECT valide qui est combinée avec select_query2.
select_query2	String	Une requête SELECT valide qui est combinée avec select_query1.

Exemple

Cet exemple utilise UNION pour fusionner deux requêtes distinctes pour des colonnes identiques dans le même ensemble de résultats.

SELECT title,
    popularity,
    vote_average
FROM movie
WHERE popularity > 800
UNION
SELECT title,
    popularity,
    vote_average
FROM movies.movie
WHERE vote_average > 7.5;

Sortie

titre	popularité	moyenne_des_votes
Les aventuriers du temple de la jungle	68.159596	7.7
Ménés	875.581305	6.4
Aucune apocalypse	49.973462	8
Superhéros 23	112.31295	7.6
Billy le Tueur	79.754966	7.7
Bang Bang Western	37.380435	7.7
Marcheur de lames	94.056131	7.9
Épées et fourreaux	123.630332	8.1
Véhicule de marchandises 5	59.995418	7.6
Odyssée de l’espace 6000	86.201184	7.9

UTILISATION

Remplace diverses configurations système pour traiter une requête spécifiée.

Le mot-clé UTILISATION est requis uniquement pour la première substitution de requête, et non pour les suivantes.

Pour obtenir des descriptions des configurations de requête prises en charge, consultez le tableau des paramètres ci-dessous.

Syntaxe

<select_query>
USING 
    [ SCHEDULING_PRIORITY = priority_value ] 
    [ MAX_ROWS_RETURNED = max_rows ]
    [ MAX_ELAPSED_TIME = max_elapsed_time ] 
    [ MAX_TEMP_DISK_USAGE = max_temp_disk_usage ] 
    [ CACHE_MAX_TIME = cache_max_time ]
    [ CACHE_MAX_BYTES = cache_max_bytes ]
    [ SERVICE CLASS service_class ]

Paramètres

Paramètre	Description
<select_query>	Une requête SELECT valide.
valeur_prioritaire	Une clause facultative qui spécifie la priority à laquelle la requête doit s’exécuter. La valeur de priorité est un nombre à virgule flottante qui indique la priorité par rapport aux autres requêtes. La valeur de priorité ne spécifie aucun pourcentage des ressources utilisées par la requête ni aucun degré spécifique de différence entre les requêtes. Si elle n’est pas spécifiée, la valeur par défaut est SCHEDULING_PRIORITY = 1.0.
max_rows	Une clause facultative qui limite le nombre de lignes renvoyées par une requête. Si une requête dépasse ce nombre de lignes, le système l’interrompt. Par exemple, max_rows_returned = 10 interrompt toute requête renvoyant plus de dix lignes.
max_elapsed_time	Une clause facultative qui limite la durée d’exécution d’une requête. Si une requête dépasse cette limite de temps en secondes, le système l’interrompt. Par exemple, max_elapsed_time = 10 interrompt toute requête prenant plus de 10 secondes.
max_temp_disk_usage	Une clause facultative qui limite le pourcentage d’espace disque temporaire utilisé par une requête. Si une requête dépasse cette limite de disque temporaire, le système l’interrompt. Par exemple, max_temp_disk_usage = 10 interrompt toute requête utilisant plus de 10 % de l’espace disque temporaire.
cache_max_time	Une clause facultative qui détermine si une requête spécifiée utilise les résultats du cache plutôt que d’exécuter la requête. S’il existe un résultat mis en cache avec le même texte de requête, exécuté il y a moins de cache_max_time secondes, la base de données utilise ce résultat mis en cache. La valeur par défaut est 0 et, par conséquent, la base de données ne renvoie aucun résultat mis en cache par défaut. Le cache prend en compte tous les SQL Nodes et, si un résultat potentiellement mis en cache est disponible uniquement sur un autre SQL Node, la base de données redirige la requête vers ce nœud. Si vous spécifiez l’attribut force sur la connexion, ce qui désactive l’équilibrage de charge et la redirection, la base de données prend en compte uniquement les résultats mis en cache sur le nœud actuel.
cache_max_bytes	Une clause facultative qui contrôle si la base de données stocke les résultats d’une requête spécifiée dans le cache. Le système stocke dans le cache les résultats de toutes les requêtes exécutées à l’aide d’une classe de service spécifiant cet attribut si la taille du résultat est inférieure à cette valeur. Vous pouvez déterminer la taille d’un ensemble de résultats en octets en interrogeant le champ bytes_returned de la table virtuelle completed_queries. La valeur par défaut est 0 et, par conséquent, la base de données ne met aucun résultat en cache par défaut. La base de données met les résultats en cache dans la mémoire des SQL Nodes. Ces résultats ne sont pas mis en cache si la mémoire disponible est insuffisante.
service_class	Une clause facultative à la fin d’une requête qui définit une classe de service spécifique pour exécuter cette requête. Pour plus de détails, consultez CRÉER UNE CLASSE DE SERVICE.

Exemple

SELECT * FROM sys.dummy10 
USING 
    SCHEDULING_PRIORITY = 1.0 
    MAX_ROWS_RETURNED = 10
    MAX_ELAPSED_TIME = 10
    MAX_TEMP_DISK_USAGE = 10;

Sortie

c1         
-----------
1 
2 
3 
4 
5 
6 
7 
8 
9 
10

TRACE

Une clause facultative qui exécute la requête, mais ignore l’ensemble de résultats d’origine. À la place, TRACE renvoie un ensemble de résultats de données de traçage qui décrivent l’exécution de la requête.

Ajoutez l’instruction SQL TRACE à la fin d’une requête. L’instruction peut inclure des paramètres facultatifs pour contrôler sa fréquence et son niveau de détail.

Pour comprendre les résultats de cette instruction, consultez Résultats TRACE.

Les requêtes de trace ont le même effet sur la charge de travail qu’une requête exécutée sans la clause.

Contactez le support Ocient pour obtenir des conseils sur l’utilisation de l’instruction SQL TRACE.

Syntaxe

<select_query> TRACE 
    [ FREQUENCY frequency_int ] 
    [ RESOLUTION resolution_int ]

Paramètres

Paramètre	Description
<select_query>	Une requête SELECT valide.
frequency_int	Contrôle la fréquence à laquelle la base de données échantillonne les événements de trace pendant l’exécution de la requête, en millisecondes. Si non spécifié, la valeur par défaut est de 500 millisecondes.
resolution_int	Détermine le niveau de détail capturé pour une trace ou un événement. Si la résolution d’une trace est supérieure à la résolution d’un événement, la base de données enregistre l’événement. Si non spécifié, la valeur par défaut est de 100 millisecondes.

Résultats TRACE

Chaque ligne de la sortie de trace fournit des informations sur ce qu’une instance d’opérateur a fait pendant la période comprise entre l’échantillon de trace précédent et l’échantillon le plus récent.

Colonne	Description
plan_parent_id	Le UUID du parent de l’instance d’opérateur dans le plan de requête. Si un opérateur possède plusieurs parents, ce champ spécifie le UUID de l’un des parents.
plan_op_id	Le UUID de l’opérateur dans le plan de requête.
operator_type	Le type d’opérateur que la base de données utilise pour échantillonner les événements de trace.
node_id	Le UUID du nœud où cet opérateur s’exécute.
code_id	L’identifiant du cœur VM où cette instance d’opérateur s’exécute. Les identifiants de cœur sont uniques pour chaque nœud.
op_id	L’identifiant de l’instance d’opérateur. Les identifiants sont uniques pour chaque nœud.
temps	Le temps en millisecondes auquel la base de données collecte les informations de l’événement de trace par rapport au début de la requête.
groupe	Regroupe les événements de trace associés.
échantillon	L’échantillon des données d’événement de trace. Pour les valeurs possibles, consultez le tableau suivant.
valeur	La valeur des données d’événement de trace.

Colonnes Sample et Value

Les colonnes échantillon et valeur décrivent ce qui s’est produit pendant une période de trace donnée.

Exemple	Description
ROWS_IN	Le nombre de lignes qu’une instance d’opérateur a lues à partir de ses opérateurs enfants.
ROWS_OUT	Le nombre de lignes renvoyées par l’instance d’opérateur.
BLOOM_FILTERED_ROWS	Le nombre de lignes que cette instance d’opérateur ignore à l’aide de filtres Bloom.
SCHEDULE_CYCLE	Le nombre de cycles dans la planification pour cette instance d’opérateur.
OOM_CYCLE	Le nombre de cycles de mémoire insuffisante dans la planification pour cet opérateur.
INITIALISER	Le moment où la base de données initialise l’opérateur.
FINALISER	Le moment où la base de données finalise l’opérateur.

Exemple

SELECT * FROM sys.dummy10 TRACE;

Sortie

plan_parent_id	plan_op_id	operator_type	node_id	core_id	op_id	group	sample	value
77041d2b-f7ca-49d5-a3f5-4b75b0782ed1	498690cf-4a9b-4c1f-affa-417f31fddc2d	RENAME_OPERATOR	08ca7b05-1e4d-455f-9f46-2174ed048d33	4	8441	xg::db::vm::operators::operatorTraceEvents	ROWS_IN	1
77041d2b-f7ca-49d5-a3f5-4b75b0782ed1	498690cf-4a9b-4c1f-affa-417f31fddc2d	RENAME_OPERATOR	08ca7b05-1e4d-455f-9f46-2174ed048d33	4	8441	xg::db::vm::operators::operatorTraceEvents	ROWS_OUT	1
77041d2b-f7ca-49d5-a3f5-4b75b0782ed1	498690cf-4a9b-4c1f-affa-417f31fddc2d	RENAME_OPERATOR	08ca7b05-1e4d-455f-9f46-2174ed048d33	4	8441	xg::db::vm::operators::operatorTraceEvents	BLOOM_FILTERED_ROWS	0

TAG

Clause facultative qui ajoute une ou plusieurs balises à la requête SQL. Vous pouvez également ajouter des balises à une expression de table commune dans la clause AVEC. Après avoir défini des balises, vous pouvez les trouver dans les tables du catalogue système sys.queries et sys.completed_queries.

Syntaxe

<select_query> <tag> [ ... ]

<tag> ::= TAG <tag_identifier>

Paramètres

Paramètre	Description
<select_query>	Une requête SELECT valide.
identifiant_tag	Identifiant de la balise pour la requête. Placez l’identifiant entre guillemets doubles s’il contient des caractères spéciaux, comme des espaces.

Exemples

Requête SQL avec une balise

Sélectionnez le nombre d’une table avec une ligne et balisez la requête avec le nom count1.

SELECT COUNT(*) FROM sys.dummy1 TAG count1;

Requête SQL avec plusieurs balises

Sélectionnez le modèle d’appareil et balisez cette requête avec les deux noms device_model et téléphones.

SELECT device_model 
FROM system.adtech_flat 
LIMIT 1 
TAG device_model 
TAG phones;

Expression de table commune avec une balise

Définissez une expression de table commune avec la balise average_budget. Vous pouvez également ajouter une autre balise pour l’ensemble de la requête overall_budget.

WITH avg_budget_table (average_budget) AS (
    SELECT AVG(budget)
    FROM movies
    TAG average_budget
)
SELECT title,
    budget,
    revenue
FROM movies,
    avg_budget_table
WHERE budget > avg_budget_table.average_budget
TAG overall_budget;

Littéraux de chaîne et séquences d’échappement

Tous les littéraux de chaîne dans les instructions SQL doivent être placés entre guillemets simples. Pour utiliser un guillemet simple dans une chaîne, vous pouvez utiliser un autre guillemet simple comme échappement, ''.

Pour les autres séquences d’échappement, incluez un caractère e avant le littéral de chaîne, c’est-à-dire avant le guillemet simple ouvrant. Cela indique au système de reconnaître les séquences d’échappement dans le littéral de chaîne. Cela signifie :

Tous les caractères \ simples dans la chaîne s’échappent maintenant eux-mêmes.

Tout caractère suivant le \ est également échappé s’il correspond à une séquence d’échappement (voir le tableau).

Si vous utilisez des séquences d’échappement, préparez-vous à devoir modifier les chaînes qui incluent \, comme les chemins de répertoire.

Séquences d’échappement prises en charge

Séquence d’échappement	Description
''	Guillemet simple
\"	Guillemet double
\n	Caractère de nouvelle ligne
\r	Caractère de retour chariot
\f	Caractère de saut de page (c’est-à-dire saut de page)
\b	Retour arrière
\\	Barre oblique inverse
	Tabulation

Exemples

Ces exemples montrent comment le système interprète les chaînes avec et sans séquences d’échappement.

Chaîne sans séquence d’échappement

Cet exemple sélectionne le littéral de chaîne simple '\my\directory\path' qui n’utilise pas de séquences d’échappement.

SELECT '\my\directory\path';

Sortie : \my\directory\path

Chaîne avec une séquence d’échappement

Cet exemple sélectionne le littéral de chaîne simple '\my\directory\path' et utilise une séquence d’échappement. Le résultat omet les barres obliques inverses.

SELECT e'\my\directory\path';

Sortie : mydirectorypath

Chaîne avec une séquence d’échappement pour conserver les barres obliques inverses

Cet exemple utilise la chaîne '\\my\\directory\\path' avec une séquence d’échappement pour inclure des barres obliques inverses dans le résultat.

SELECT e'\\my\\directory\\path';

Sortie : \my\directory\path

Séquences d’échappement avec des expressions régulières

Soyez prudent lorsque vous utilisez des séquences d’échappement avec des chaînes qui utilisent également des expressions régulières. Les séquences d’échappement dans la syntaxe SQL remplacent les séquences d’échappement des expressions régulières.

Dans cet exemple, la fonction REGEXP_SUBSTR utilise l’expression régulière \w+ pour correspondre à n’importe quels caractères de mot.

SELECT REGEXP_SUBSTR(
    'abcdefghijklmnopqrstuvwxyz', 
    '\w+'
    );

Sortie : abcdefghijklmnopqrstuvwxyz

La fonction se comporte différemment si l’expression régulière est une séquence d’échappement, car elle remplace le caractère \ . L’expression régulière recherche uniquement le caractère w.

SELECT REGEXP_SUBSTR(
    'abcdefghijklmnopqrstuvwxyz', 
    e'\w+'
    );

Sortie : w

Liens connexes

Référence SQL

Référence des instructions Data Control Language (DCL)

Référence des instructions Data Definition Language (DDL)