SELECT (pour extraire des lignes)

La commande SELECT permet d'extraire des lignes d'une table ou d'une vue. Il renvoie les lignes qui satisfont aux critères que vous avez spécifiés, y compris la condition WHERE. Si vous omettez la condition WHERE, la commande SELECT sélectionne toutes les lignes.

Note : Pour une description de l'utilisation de la commande SELECT pour lancer une procédure stockée sur un hôte Netezza Performance Server, voir la commande SELECT.

Le système forme des lignes de sortie en calculant les expressions de sortie sélectionnées pour chaque ligne sélectionnée.

Vous pouvez inclure * dans la liste de sortie pour indiquer toutes les colonnes des lignes sélectionnées. Vous pouvez également indiquer " <table>.* pour désigner les colonnes provenant d'une table spécifique. L'interrogation d'un tableau décrit les fonctions que vous pouvez utiliser dans une commande SELECT.
Vous pouvez utiliser le mot-clé distinct pour éliminer les lignes dupliquées du résultat. Le mot-clé all (par défaut) renvoie toutes les lignes candidates, y compris les doublons.

Syntaxe

Syntaxe permettant d'utiliser la commande SELECT pour extraire des lignes d'une table ou d'une vue :

SELECT [ DISTINCT | ALL ] [ * | <col> [ AS <output_name> ]
  <expression> [ AS <output_name> ] [,<expression> [ AS <output_name> ]…]
    [ FROM <from_item>[,<from_item>…] ]
    [ WHERE <condition> ]
    [ GROUP BY <expression>[,<expression>…] ]
    [ HAVING <condition>[,<condition>…] ]
    [ { UNION | INTERSECT | EXCEPT | MINUS }[ DISTINCT | ALL ]
SELECT
    [ ORDER BY <expression> [ ASC | DESC | USING <operator>
                          [NULLS {FIRST | LAST}][, …] ]
    [ LIMIT { <count> | ALL } ]

Où <from_item> représente :

<table>
     [ [ AS ] <alias> [ ( <column_alias_list> ) ] ] |
     [ FOR SYSTEM_TIME 
       { AS OF <timestamp-expression> | 
         BEFORE <timestamp-expr> | 
         BETWEEN <timestamp-expression1> AND <timestamp-expression2> | 
         FROM <timestamp-expression1> TO <timestamp-expression2> } ] |
     ( <select> ) [ AS ] <alias> [ ( <column_alias_list> ) ] |
      <from_item> [ NATURAL ] <join_type> <from_item>
         [ ON <join_condition> | USING ( <join_column_list> ) ]

Pour plus d'informations sur FOR SYSTEM_TIME, voir Syntaxe des requêtes de déplacement dans le temps et horodatage.

Entrées

La commande SELECT prend en compte les données suivantes :

Tableau 1. SELECT entrées
Entrée	Descriptif
alias	Spécifie un nom de remplacement pour le nom de la table précédente. Utilisez un alias par souci de concision ou pour éliminer toute ambiguïté en cas de jointure automatique (lorsque la même table est analysée plusieurs fois). Si vous écrivez un alias, vous pouvez également écrire une liste d'alias de colonnes pour fournir des noms de substitution pour une ou plusieurs colonnes du tableau.
<col>	Nom d'une colonne.
<nom_de_sortie>	Nom à donner à la colonne dans la sortie. Ce nom est généralement utilisé pour étiqueter une colonne à des fins d'affichage. Vous pouvez également l'utiliser pour faire référence à la valeur de la colonne dans les clauses ORDER BY et GROUP BY. Vous ne pouvez pas utiliser ce nom dans les clauses WHERE ou HAVING ; écrivez l'expression à la place.
<expression>	Le nom d'une colonne du tableau ou d'une expression.
FROM	La clause FROM spécifie une ou plusieurs tables sources pour la commande SELECT. Si vous spécifiez plusieurs sources, le résultat est le produit cartésien de toutes les lignes de toutes les sources. En général, cependant, vous ajoutez des conditions de qualification pour restreindre les lignes que le système renvoie à peu de produits cartésiens. Vous pouvez mettre entre parenthèses une commande de sous-sélection dans une clause FROM. L'utilisation d'une commande de sous-sélection est le seul moyen d'obtenir plusieurs niveaux de regroupement, d'agrégation ou de tri dans une seule requête. Vous devez spécifier un alias pour la commande subselect. Un élément FROM peut être une clause de jointure, qui combine deux éléments from plus simples. Utilisez des parenthèses, si nécessaire, pour déterminer l'ordre d'emboîtement.
<from_item>	Une référence de table, une sous-sélection ou une clause de jointure. Pour plus d'informations sur FOR SYSTEM_TIME, voir Syntaxe des requêtes de déplacement dans le temps et horodatage.
LIEU	Cette clause a la forme générale suivante : `WHERE boolean_expr` La partie boolean_expr de la clause peut consister en toute expression produisant une valeur booléenne. Dans de nombreux cas, vous utilisez l'expression comme suit : `expr cond_op expr or log_op expr` où : cond_op peut être l'un des opérateurs suivants : =, <, <=, >, >= ou <>, un opérateur conditionnel tel que all, any, in, like, ou un opérateur défini localement. log_op peut être l'un des éléments suivants : and, or, not. select ignore toutes les lignes pour lesquelles la condition WHERE ne renvoie pas un résultat positif.
REGROUPER PAR	Cette clause permet de diviser une table en groupes de lignes correspondant à une ou plusieurs valeurs. La clause spécifie une table groupée qui est dérivée par l'application de la clause : `GROUP BY <expression>[,<expression>…]` La clause GROUP BY condense, en une seule ligne, toutes les lignes sélectionnées qui partagent des valeurs pour les colonnes regroupées. Le système calcule les fonctions d'agrégation sur toutes les lignes qui composent chaque groupe, produisant une valeur distincte pour chaque groupe (alors que sans GROUP BY, un agrégat produit une valeur unique calculée sur toutes les lignes sélectionnées). Lorsque vous incluez la clause GROUP BY, l'expression ou les expressions de sortie de la commande SELECT ne peuvent pas faire référence à des colonnes non groupées, sauf dans les fonctions d'agrégation, car il y aurait plus d'une valeur possible à renvoyer pour une colonne non groupée. Un groupe par valeur peut être : Un nom de colonne d'entrée. Le nom ou le numéro ordinal d'une colonne de sortie (expression de sélection). Une expression arbitraire formée à partir des valeurs des colonnes d'entrée. En cas d'ambiguïté, le système interprète un nom de groupe comme un nom de colonne d'entrée plutôt que comme un nom de colonne de sortie.
HAVING	La clause facultative HAVING a la forme générale suivante `HAVING boolean_expr` où l'expression booléenne est la même que celle spécifiée pour la clause where. La clause HAVING spécifie un tableau groupé dérivé par l'élimination des lignes qui ne satisfont pas à l'expression booléenne. La clause HAVING est différente de la clause WHERE : La clause WHERE filtre les lignes individuelles avant l'application du GROUP BY. La clause HAVING filtre les lignes de groupe créées par GROUP BY. Chaque colonne référencée dans boolean_expr doit faire référence sans ambiguïté à une colonne de regroupement, sauf si la référence est affichée dans une fonction d'agrégation. Dans une sélection de regroupement, la clause HAVING ne peut faire référence qu'à des expressions à valeur unique au sein d'un groupe. En d'autres termes, vous ne pouvez faire référence qu'à des champs de groupe, des agrégats ou des expressions à valeur unique dérivées de champs de groupe ou d'agrégats (qui doivent inclure des constantes). Par exemple, pour renvoyer le groupe et le nombre de groupes ayant plus de quatre membres : `SELECT grp, count(id) AS n FROM emp GROUP BY grp HAVING n > 4` Dans une sélection sans regroupement, où la sélection est conceptuellement regroupée par des champs de groupe zéro, vous ne pouvez faire référence qu'à des agrégats ou à des expressions à valeur unique. Par exemple, pour ne renvoyer aucune ligne s'il y a quatre salariés ou moins dans emp, ou une ligne avec le décompte s'il y a plus de quatre salariés dans emp : `SELECT count(id) AS n FROM emp HAVING n > 4`
<condition>	Une expression booléenne qui donne un résultat vrai ou faux.
UNION	L'opérateur fait en sorte que le système calcule la collection de lignes renvoyées par les requêtes. Élimine les lignes en double, sauf si vous spécifiez le mot-clé ALL. `table_query UNION [ ALL ] table_query [ ORDER BY <expression> [ASC\|DESC\|USING operator] [, …] ] [ LIMIT { COUNT \| ALL } ] [ OFFSET start ]` où table_query spécifie toute expression de sélection sans clause ORDER BY, FOR UPDATE ou LIMIT. Si vous placez une sous-expression entre parenthèses, vous pouvez inclure les clauses ORDER BY et LIMIT. Si vous n'incluez pas de parenthèses, les clauses sont considérées comme s'appliquant au résultat de l'union, et non à son expression d'entrée droite. L'opérateur UNION calcule la collection (union d'ensembles) des lignes renvoyées par les requêtes concernées. Les deux sélections qui représentent les opérandes directs de l'union doivent produire le même nombre de colonnes, et les colonnes correspondantes doivent être de types de données compatibles. Le résultat de l'UNION ne contient pas de lignes dupliquées à moins que vous ne spécifiiez l'option ALL. L'option TOUS permet d'éviter l'élimination des doublons. Les opérateurs UNION multiples dans la même commande SELECT sont évalués de gauche à droite, à moins que vous n'indiquiez le contraire en utilisant des parenthèses.
INTERSECTION	Combine les résultats de deux requêtes en un seul résultat qui comprend toutes les lignes communes aux deux requêtes. Pour plus d'informations, voir l' opération INTERSECT.
SAUF ou MOINS	Recherche la différence entre les deux requêtes et le résultat comprend les lignes qui appartiennent uniquement à la première requête. Pour plus d'informations, voir l' opération SAUF.
TRIER PAR	Utilisez cette clause pour trier les lignes renvoyées dans l'ordre que vous avez spécifié. Une clause ORDER BY peut être : Le nom ou le numéro ordinal d'une colonne de sortie (expression de sélection). Le numéro ordinal fait référence à la position ordinale (de gauche à droite) de la colonne de résultats. Cette fonctionnalité permet de définir un ordonnancement basé sur une colonne qui n'a pas de nom. Par exemple : `SELECT title, date_prod + 1 AS newlen FROM films ORDER BY newlen;` Expression arbitraire formée à partir des valeurs des colonnes d'entrée, y compris les champs qui ne s'affichent pas dans la liste des résultats de la sélection. Par exemple : `SELECT name FROM distributors ORDER BY code;` En cas d'ambiguïté, un nom ORDER BY est interprété comme un nom de colonne de sortie. Cette fonctionnalité est limitée par le fait qu'une clause ORDER BY qui s'applique au résultat d'une requête d'union ne peut spécifier que le nom ou le numéro d'une colonne de sortie, et non une expression. Si une clause ORDER BY est un nom simple qui correspond à la fois à un nom de colonne de résultat et à un nom de colonne d'entrée, ORDER BY l'interprète comme le nom de la colonne de résultat. C'est le contraire du choix que fait la clause GROUP BY dans la même situation. Vous pouvez spécifier un ordre de tri ascendant ou descendant : vérificateur de syntaxe abstraite Trier par ordre croissant. Cela équivaut à utiliser <. Il s'agit de la valeur par défaut DECROISSANT Trier par ordre décroissant. Cela équivaut à utiliser >. Vous pouvez spécifier un ordre de tri pour les données nulles : NULLS FIRST Les valeurs nulles sont placées avant les valeurs non nulles. Pour un tri ascendant, les zéros s'affichent en premier dans la sortie ; pour un tri descendant, ils s'affichent en dernier. Il s'agit de la valeur par défaut NULLS LAST Les valeurs nulles viennent après les valeurs non nulles.
Limite	Renvoyer un sous-ensemble des lignes produites par votre requête : <compter> Renvoie au maximum le nombre de lignes spécifié. TOUS Renvoyer toutes les lignes. Il s'agit de la valeur par défaut. Lorsque vous spécifiez le paramètre LIMIT, spécifiez également le paramètre ORDER BY. Dans le cas contraire, le sous-ensemble de lignes renvoyé est indéterminé.
<joindre_liste_colonnes>	Une liste de colonnes de jointure. Par exemple, spécifier " `USING (a,b)` équivaut à spécifier " `ON left_table.a = right_table.a` et " `ON left_table.b = right_table.b`.
<condition_de_jonction>	Une condition de qualification. Cette condition est similaire à la condition WHERE, sauf qu'elle ne s'applique qu'aux deux éléments from_items réunis dans cette clause de jointure.
<type_d'adhésion>	L'un des types de jointure suivants : jOIN [INNER] JOIN JOINTURE [EXTERNE] GAUCHE JOINTURE [EXTERNE] DROITE JOINTURE [EXTERNE] COMPLÈTE JOINT CROISÉ Pour un type de jointure interne ou externe, vous devez inclure exactement l'une des clauses suivantes : NATURAL Activé<join_condition> UTILISATION (<join_column_list>) N'incluez aucune de ces clauses pour une jointure croisée.
<select>	Une commande SELECT. Vous devez placer la sous-sélection entre parenthèses et lui donner un alias. Lorsque vous incluez une sous-sélection dans la clause FROM, la sous-sélection agit comme si sa sortie avait été créée en tant que table temporaire au cours de cette seule commande de sélection.
<table>	Dans une clause FROM, le nom d'une table ou d'une vue.
CROSS JOIN et INNER JOIN	Produit un simple produit cartésien, le même que celui que vous obtiendriez en listant les deux éléments au niveau supérieur de FROM. La jointure croisée et la jointure interne sur les types (true) sont équivalentes ; aucune ligne n'est supprimée par qualification. Ces types de jonctions sont une commodité nota-tionnelle. Vous pouvez obtenir les mêmes résultats en utilisant les clauses FROM et WHERE.
JOINTURE EXTERNE SUR L'ELEMENT DE GAUCHE	Renvoie toutes les lignes du produit cartésien qualifié (c'est-à-dire toutes les lignes combinées qui satisfont à sa condition d'activation), plus une copie de chaque ligne du tableau de gauche pour laquelle aucune ligne de droite n'a satisfait à la condition d'activation. Le système ne prend en compte que la condition "own on" ou "using" de la jointure pour déterminer les lignes qui ont des correspondances. Il applique ensuite les conditions OUTER ON ou WHERE.
Jointure externe droite	Renvoie toutes les lignes jointes, plus une ligne pour chaque ligne de droite non appariée (étendue avec des zéros à gauche). Il s'agit d'une simple commodité d'écriture. Vous pouvez la convertir en une jointure externe gauche en inversant les entrées gauche et droite.
JOINTURE EXTERNE COMPLETE	Renvoie toutes les lignes jointes, plus une ligne pour chaque ligne gauche non appariée (étendue avec des zéros à droite), plus une ligne pour chaque ligne droite non appariée (étendue avec des zéros à gauche). Pour tous les types de jointure, à l'exception de la jointure croisée, vous devez écrire exactement l'un des éléments suivants : Activé<join_condition> C'est le cas le plus général. Vous pouvez écrire n'importe quelle expression de qualification qui implique les deux tables que vous voulez joindre. Utilisation d'<join_column_list> Par exemple, spécifier " `USING (a,b)` équivaut à spécifier " `ON left_table.a = right_table.a` et " `ON left_table.b = right_table.b`. Le terme UTILISER implique qu'une seule de chaque paire de colonnes équivalentes doit être incluse dans la sortie de la jointure, et non les deux. NATURAL Utilisez une liste d'UTILISATION qui mentionne toutes les colonnes portant un nom similaire dans les tableaux.

Sorties

La commande SELECT a les résultats suivants :

Tableau 2. Sélection de sorties
Sortie	Descriptif
`ROWS`	Renvoie l'ensemble des lignes résultant de la requête.
`COUNT`	Renvoie le nombre de lignes renvoyées par la requête.

Droits

Vous devez être l'utilisateur admin, le propriétaire de la table, le propriétaire de la base de données ou du schéma dans lequel la table est définie, ou votre compte doit disposer des privilèges Select sur la table ou la classe d'objets Table (ou la classe Table externe, si la table sélectionnée est une table externe).

Utilisation

Voici un exemple d'utilisation.

Joindre la table 'films à la table 'distributors:

MYDB.SCH1(USER)=> SELECT f.title, f.did, d.name, f.date_prod, f.kind
FROM distributors d, films f WHERE f.did = d.did;

   title                     |did  |name              |date_prod  |kind
   --------------------------+-----+------------------+-----------+-------
   The Third Man             |101  |British Lion      |1949-12-23 |Drama
   The African Queen         |101  |British Lion      |1951-08-11 |Romantic
   Une Femme est une Femme   |102  |Jean Luc Godard   |1961-03-12 |Romantic
   Vertigo                   |103  |Paramount         |1958-11-14 |Action
   Becket                    |103  |Paramount         |1964-02-03 |Drama
   48 Hours                  |103  |Paramount         |1982-10-22 |Action
   War and Peace             |104  |Mosfilm           |1967-02-12 |Drama
   West Side Story           |105  |United Artists    |1961-01-03 |Musical
   Bananas                   |105  |United Artists    |1971-07-13 |Comedy
   Yojimbo                   |106  |Toho              |1961-06-16 |Drama
   There's a Girl in my Soup |107  |Columbia          |1970-06-11 |Comedy
   Taxi Driver               |107  |Columbia          |1975-05-15 |Action
   Absence of Malice         |107  |Columbia          |1981-11-15 |Action
   Storia di una donna       |108  |Westward          |1970-08-15 |Romantic
   The King and I            |109  |20th Century Fox  |1956-08-11 |Musical
   Das Boot                  |110  |Bavaria Atelier   |1981-11-11 |Drama

Additionnez la colonne " len de tous les films et regroupez les résultats par type :

MYDB.SCH1(USER)=> SELECT kind, SUM(len) AS total FROM films GROUP BY
kind;
   kind     |total
   ---------+-------
   Action   |07:34
   Comedy   |02:58
   Drama    |14:28
   Musical  |06:42
   Romantic |04:38

Additionner la colonne " len de tous les films, regrouper les résultats par type et afficher les totaux des groupes inférieurs à 5 heures :

MYDB.SCH1(USER)=> SELECT kind, SUM(len) AS total FROM films GROUP BY
kind HAVING SUM(len) < INTERVAL '5 HOUR';
   kind     | total
   ---------+------
   Comedy   | 02:58
   Romantic | 04:38

Trier le contenu du tableau " distributors en fonction du contenu de la deuxième colonne (name) :

MYDB.SCH1(USER)=> SELECT * FROM distributors ORDER BY name;
or
MYDB.SCH1(USER)=> SELECT * FROM distributors ORDER BY 2;
   did   | name
   ------+-----------------
   109   | 20th Century Fox
   110   | Bavaria Atelier
   101   | British Lion
   107   | Columbia
   102   | Jean Luc Godard
   113   | Luso Films
   104   | Mosfilm
   103   | Paramount
   106   | Toho
   105   | United Artists
   111   | Walt Disney
   112   | Warner Bros.
   108   | Westward

Obtenez l'union des tableaux 'distributors et 'actors, et limitez les résultats à ceux qui commencent par la lettre W :

MYDB.SCH1(USER)=> SELECT distributors.name
      FROM distributors
      WHERE distributors.name LIKE 'W%';
      UNION
      SELECT actors.name
      FROM actors
      WHERE actors.name LIKE 'W%';
   Walt Disney
   Walter Matthau
   Warner Bros.
   Warren Beatty
   Westward
   Woody Allen

Étant donné que seules les lignes distinctes sont recherchées, le mot-clé ALL est omis.

considérations watsonx.data

Avec la version 11.2.2.9

Apache Iceberg n'ont pas de longueur maximale de caractère pour le type de données string , ce qui entraîne une divergence avec la façon dont le système Netezza Performance Server traite les types de texte. Afin de compenser cela, Netezza traitera toutes les colonnes de chaînes comme ayant une longueur de 512 caractères. Si vos données contiennent une chaîne de caractères dont la longueur est supérieure à 512 caractères, la requête échouera avec une erreur de dépassement de capacité.
Solution :
- Fixez la taille de la variable DATALAKE_STRING_SIZE à une valeur plus élevée pour dépasser la limite de 512 caractères par défaut.
- Alternativement, vous pouvez manuellement convertir la colonne string en un type Netezza NVARCHAR avec la taille requise.
  Par exemple, pour passer à 4096 caractères, exécutez :
```
SELECT stringCol::NVARCHAR(4096) FROM ...
```
  Si, au cours d'une telle conversion, des données dépassent encore 4Kb de l'espace alloué, le reste des données est tronqué à la taille spécifiée.
Vous devez également tenir compte des aspects suivants :
- La variable de session DATALAKE_STRING_SIZE est appliquée à toutes les colonnes de type string dans une table.
- Si vous souhaitez traiter une colonne différemment d'une autre, vous pouvez donner à chaque colonne une taille différente.
- La conversion n'est possible que pour le type NVARCHAR().
- La portée de la variable de session DATALAKE_STRING_SIZE est [1, 16000].
- Un comportement similaire est également applicable au type de données binary, qui utilise sa propre variable d'environnement DATALAKE_BINARY_SIZE avec la même taille par défaut de 512 octets et la même plage effective de [1, 64000].
Si des noms de schéma dans Hive Metastore sont des mots-clés NPS, vous ne pouvez pas utiliser ces mots-clés comme identifiants lors de l'utilisation du schéma. Pour plus d'informations, voir Noms de schéma dans Hive Metastore (HMS) qui sont des mots-clés réservés NPS.