---
title: page de test Ocient
slug: spanish/page-de-test-ocient
createdAt: 2025-12-05T14:45:17.383Z
---

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.&#x20;

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

**Syntaxe**

```sql
[ 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.&#x20;

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. &#x20;

## 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.&#x20;

**Syntaxe**

```sql
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. <br />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. <br />`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.<br />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. <br />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.&#x20;

```sql
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.&#x20;

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 .  &#x20;

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

**Syntaxe**

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

**Paramètres**

| **Paramètre**    | Description                                                                                                                                                             |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `TOUT`           | `SELECT` et `TOUT SÉLECTIONNER` sont identiques. <br />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.&#x20;

**Syntaxe**

```sql
<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. <br />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.&#x20;

**Exemples**

### Utilisation de SELECT \*&#x20;

Cet exemple utilise `SELECT *` pour renvoyer toutes les colonnes de la table `movies`.&#x20;

```sql
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.

```sql
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.&#x20;

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`.

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

Insérez quatre enregistrements dans la table `produits`.

```sql
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.

```sql
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.&#x20;

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.&#x20;

```sql
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**

```sql
<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. <br />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. <br />Chaque sous-requête doit être placée entre parenthèses avec un nom de corrélation facultatif.<br />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. <br />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. &#x20;

**Syntaxe**

```sql
<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. <br />Pour plus de détails, consultez SELECT.                                                                                                                                                                                           |
| `<table_reference1>` | Soit un nom de table ou une requête `SELECT` complète entre parenthèses<br />`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.  <br />`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`  <br />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`  <br />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`.&#x20;

**Syntaxe**

```sql
<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. <br />`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.<br /> `RIGHT JOIN` effectue la même opération que `JOINTURE EXTERNE DROITE`.                                                                        |
| `FULL OUTER JOIN`         | Retourne toutes les lignes correspondantes et non correspondantes.<br />`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.                                                                                                     |

::::hint{type="info"}
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.&#x20;

:::BlockQuote
SELECT \* FROM
&#x9;(
&#x9;SELECT
&#x9;	1 AS cx1,
&#x9;	2 AS cx2) AS x
INNER JOIN LATERAL (
&#x9;SELECT
&#x9;	x.cx1 AS cy1,
&#x9;	x.cx2 AS cy2) AS y&#x20;
ON
&#x9;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 :&#x20;

- `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. &#x20;

| 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.&#x20;

| 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&#x20;

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.

```sql
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).&#x20;

```sql
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).&#x20;

```sql
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.&#x20;

```sql
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É`.&#x20;

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

*Résultat*

:::hint{type="info"}
Comme l’ensemble de résultats pour cet exemple de CROSS JOIN contient plus de 200 lignes, les résultats sont abrégés.&#x20;
:::

| 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.&#x20;

```sql
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.&#x20;

```sql
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.&#x20;

**Syntaxe**

```sql
<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é. <br />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`. <br />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`.&#x20;

**Syntaxe**

```sql
<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. <br />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. <br />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. <br />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. <br />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. <br />Pour plus de détails, consultez Filtres de tableau.                                                                                                                                                                                                                                                                                                                                                                                                                                   | `FOR_SOME(col_int_array) > 10`<br /><br />`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. <br />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. <br />Pour plus de détails, consultez Filtres de tableau.                                                                                                                                                                                                                                                                                                                                                                                                                  | `FOR_ALL(col_int_array) > 10`<br /><br />`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 NULL`NULL` doivent être traitées comme des points de données significatifs.<br />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`. <br />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.&#x20;

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.&#x20;

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

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.&#x20;

**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.&#x20;

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

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

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

```sql
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`.

```sql
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`.&#x20;

```sql
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`.&#x20;

```sql
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`.&#x20;

*Sortie*

```none
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.&#x20;

```sql
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.&#x20;

*Sortie*

```none
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`.

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

*Résultat*

```none
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`.&#x20;

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

*Résultat :&#x20;*`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.&#x20;

`%` 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**

```sql
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.                                                                                                                                                                                                                          |

:::hint{type="info"}
- 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**

```sql
'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 :&#x20;

- 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.&#x20;

- `FOR_ALL()` évalue un tableau vide comme étant `VRAI`.&#x20;
- `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%` :

```sql
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.&#x20;

**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.&#x20;

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 :&#x20;

```sql
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. &#x20;

**Syntaxe**

```sql
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`. <br />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()`. <br />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. <br />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. <br />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.&#x20;

```sql
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.&#x20;

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

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

**Syntaxe**

```sql
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. <br />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 $. &#x20;

```sql
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. &#x20;

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

**Syntaxe**

```sql
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`. <br />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. <br />Indique si la colonne doit être triée en ordre croissant (`ASC`) ou décroissant (`DESC`). <br />Si non spécifié, la valeur par défaut est `ASC`.                                                                                                            |
| `NULLS FIRST \| NULLS LAST` | Chaîne              | Facultatif. <br />`NULLS FIRST` signifie que les valeurs nulles sont placées au début du jeu de résultats. <br />`NULLS LAST` signifie que les valeurs nulles sont placées à la fin du jeu de résultats. <br /><br />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. &#x20;

```sql
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.&#x20;

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

**Syntaxe**

```sql
<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.&#x20;

```sql
SELECT title FROM movies LIMIT 3; 
```

*Sortie*

```sql
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.&#x20;

```sql
SELECT c1 FROM sys.dummy10 LIMIT 1+2; 
```

*Sortie*

```sql
1
2
3
```

## OFFSET

Ignore un nombre spécifié de lignes du jeu de résultats.&#x20;

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

**Syntaxe**

```sql
<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.&#x20;

```sql
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.&#x20;

```sql
SELECT c1 FROM sys.dummy10 OFFSET 3+4; 
```

*Résultat*

```sql
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.  &#x20;

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.&#x20;

**Syntaxe**

```sql
<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.&#x20;

```sql
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.&#x20;

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 .   &#x20;

**Syntaxe**

```sql
<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`.<br />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`.

```sql
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.&#x20;

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.&#x20;

**Syntaxe**

```sql
<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.&#x20;

```sql
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.&#x20;

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

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

**Syntaxe**

```sql
<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. <br />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.<br />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. <br />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. <br />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. <br />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.<br />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.<br />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.<br />Pour plus de détails, consultez CRÉER UNE CLASSE DE SERVICE.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

**Exemple**

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

*Sortie*

```sql
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.&#x20;

Pour comprendre les résultats de cette instruction, consultez Résultats TRACE.&#x20;

:::hint{type="info"}
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.
:::

:::hint{type="warning"}
Contactez le support Ocient pour obtenir des conseils sur l’utilisation de l’instruction SQL TRACE.
:::

**Syntaxe**

```sql
<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.<br />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. <br />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.<br />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**

```sql
SELECT * FROM sys.dummy10 TRACE;
```

*Sortie*

| plan\_parent\_id                     | plan\_op\_id                         | operator\_type   | node\_id                             | core\_id | op\_id | time | group                                          | sample                | value |
| ------------------------------------ | ------------------------------------ | ---------------- | ------------------------------------ | -------- | ------ | ---- | ---------------------------------------------- | --------------------- | ----- |
| 77041d2b-f7ca-49d5-a3f5-4b75b0782ed1 | 498690cf-4a9b-4c1f-affa-417f31fddc2d | RENAME\_OPERATOR | 08ca7b05-1e4d-455f-9f46-2174ed048d33 | 4        | 8441   | 0    | 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   | 0    | 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   | 0    | 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**

```sql
<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`.

```sql
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`.

```sql
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`.

```sql
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, `''`*.&#x20;*

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 :&#x20;

- 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). &#x20;

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

**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.&#x20;

**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.&#x20;

```sql
SELECT '\my\directory\path';
```

*Sortie :&#x20;*`\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.&#x20;

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

*Sortie :&#x20;*`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. &#x20;

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

*Sortie :&#x20;*`\my\directory\path`

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

:::hint{type="info"}
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.&#x20;
:::

Dans cet exemple, la fonction REGEXP\_SUBSTR utilise l’expression régulière `\w+` pour correspondre à n’importe quels caractères de mot.&#x20;

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

*Sortie :&#x20;*`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`.&#x20;

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

*Sortie :&#x20;*`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)
