Resource Management:Basic SQL syntax

	SELECT [DISTINCT] column1 [AS column_name], column2, function
	FROM table_name
	[JOIN table_name ON join_condition]
	[WHERE search_condition]
	[GROUP BY column1, column2, ...]
	[HAVING search_condition]
	[ORDER BY column1 [ASC|DESC], column2 [ASC|DESC], ...]
	[LIMIT number_of_rows OFFSET start_row]

Liste SELECT

La liste SELECT se situe entre les clauses SELECT et FROM. Elle spécifie les colonnes à renvoyer et prend en charge les alias, les expressions arithmétiques, les opérations sur les chaînes et les appels de fonction.

Le code suivant illustre la syntaxe :

SELECT 
	column1, column2, ... , columnN 
FROM 
	table_name;

• column1, column2,...columnN représentent les noms des colonnes de la table.

• table_name correspond au nom de la table.

Utilisez l'un des modèles SELECT suivants en fonction de vos besoins :

Interrogez toutes les colonnes de la table.

SELECT
	*
FROM
	table_name;

Interrogez des colonnes spécifiques de la table.

SELECT
	column1, column2, ...columnN
FROM
	table_name;

Attribuez un alias à une colonne.

SELECT 
	column1 AS alias_name 
FROM 
	table_name; 

Calculez une valeur à partir de deux colonnes.

SELECT 
	column1 + column2 AS expression 
FROM 
	table_name;

FROM

La clause FROM spécifie la ou les tables à interroger. Si plusieurs tables sont répertoriées, la portée de la requête correspond au produit cartésien (jointure croisée) de ces tables. Utilisez la clause WHERE pour restreindre le résultat à un sous-ensemble utile.

La clause FROM prend en charge les éléments suivants :

• table_name : nom d'une table existante.

• alias : alias pour une table, qui simplifie les références et élimine les ambiguïtés. Lorsque vous attribuez un alias, le nom de la table d'origine est masqué. Par exemple, FROM resources AS a signifie que toutes les autres clauses doivent référencer a pour accéder à la table resources.

• select : sous-requête dans la clause FROM. Le résultat de la sous-requête devient une table temporaire, sur laquelle s'exécute la requête externe. Placez la sous-requête entre parenthèses et attribuez-lui un alias.

• join_type : type de jointure. Pour plus d'informations, consultez la section JOIN.

Dans la recherche avancée, la table resources constitue la table de données principale qui stocke les propriétés des ressources. Pour consulter son schéma, reportez-vous à la section Table utilisée pour les requêtes de la vue d'ensemble.

JOIN

La clause JOIN combine les lignes de deux tables ou plus en fonction de colonnes partagées. Cinq types de jointures sont pris en charge : sélectionnez le type adapté aux données dont vous avez besoin.

• CROSS JOIN : renvoie le produit cartésien de deux tables, c'est-à-dire chaque ligne d'une table associée à chaque ligne de l'autre. Utilisez cette option pour générer toutes les combinaisons de données possibles.

• INNER JOIN : renvoie uniquement les lignes correspondant aux deux tables en fonction des colonnes communes.

• LEFT OUTER JOIN : renvoie toutes les lignes de la table de gauche et les lignes correspondantes de la table de droite. Renvoie NULL pour les colonnes de la table de droite lorsqu'il n'y a pas de correspondance.

• RIGHT OUTER JOIN : renvoie toutes les lignes de la table de droite et les lignes correspondantes de la table de gauche. Renvoie NULL pour les colonnes de la table de gauche lorsqu'il n'y a pas de correspondance.

• FULL OUTER JOIN : renvoie toutes les lignes des deux tables. Renvoie NULL pour les colonnes du côté non correspondant.

WHERE

La clause WHERE filtre les lignes selon une condition. Le code suivant présente la syntaxe :

SELECT 
	column1, column2, ... , columnN 
FROM 
	table_name 
WHERE 
	[condition]

La clause WHERE prend en charge les types d'opérateurs suivants :

• Opérateurs de comparaison :

  Utilisez = pour renvoyer les lignes présentant une correspondance exacte. Par exemple, interrogez toutes les instances Elastic Compute Service (ECS) :

  SELECT 
  	resource_id,
  	resource_name,
  	resource_type,
   	region_id,
   	account_id 
  FROM 
  	resources 
  WHERE 
  	resource_type = 'ACS::ECS::Instance';

  Utilisez >, <, >=, <= ou != pour filtrer par plage ou inégalité. Par exemple, interrogez les ressources créées après une date spécifique :

  SELECT
  	resource_id,
   	resource_name,
   	region_id,
   	resource_type,
   	account_id,
   	create_time
  FROM
   	resources
  WHERE
   	create_time > '20230607';

• Opérateurs logiques :

  Utilisez AND, OR et NOT pour combiner plusieurs conditions de filtrage.

  AND renvoie les lignes qui satisfont toutes les conditions spécifiées. Par exemple, interrogez les instances ECS dans la région Chine (Hangzhou) :

  SELECT
  	resource_id,
  	resource_name,
  	resource_type,
  	region_id,
  	account_id
  FROM
  	resources
  WHERE
  	region_id = 'cn-hangzhou'
  	AND resource_type = 'ACS::ECS::Instance';

  OR renvoie les lignes qui satisfont l'une des conditions spécifiées. Par exemple, interrogez les instances ECS et leurs disques attachés :

  SELECT
  	resource_id,
  	resource_name,
  	resource_type,
  	region_id,
  	account_id
  FROM
  	resources
  WHERE
  	resource_type = 'ACS::ECS::Disk'
  	OR resource_type = 'ACS::ECS::Instance';

• Opérateur LIKE :

  LIKE effectue une correspondance floue et est généralement utilisé avec des caractères génériques. PostgreSQL prend en charge deux caractères génériques :

  • Signe pourcentage (%) : correspond à zéro caractère ou plus, quelle que soit la longueur.

  • Trait de soulignement (_) : correspond à exactement un caractère.

  Sans caractères génériques, LIKE se comporte de manière identique à =. Par exemple, interrogez tous les types de ressources ECS à l'aide d'un caractère générique de suffixe :

  SELECT
   resource_id,
   resource_name,
   region_id,
   zone_id,
   resource_type,
   account_id
  FROM
   resources
  WHERE
   resource_type LIKE 'ACS::ECS::%';

• Opérateur IN :

  IN vérifie si une valeur apparaît dans une liste et renvoie true si c'est le cas.

  SELECT 
  	column1, column2, ... , columnN 
  FROM 
  	table_name 
  WHERE 
  	exp IN (value1, value2, ..., valueN);

  • exp peut être un nom de colonne, une valeur ou une expression telle qu'un appel de fonction ou une opération arithmétique.

  • value1, value2, ..., valueN représente la liste des valeurs. Séparez les valeurs par des virgules (,).

  Par exemple, interrogez les instances ECS et leurs disques attachés :

  SELECT
  	resource_id,
  	resource_name,
  	region_id,
  	zone_id,
  	resource_type,
  	account_id
  FROM
  	resources
  WHERE
  	resource_type IN('ACS::ECS::Instance', 'ACS::ECS::Disk');

• Opérateurs NULL :

  IS NULL vérifie si une colonne a une valeur NULL. IS NOT NULL vérifie si une colonne a une valeur non NULL. Par exemple, interrogez les ressources où resource_name est NULL :

  SELECT
  	resource_id,
  	resource_name,
  	region_id,
  	zone_id,
  	resource_type,
  	account_id
  FROM
  	resources
  WHERE
  	resource_name IS NULL;

ORDER BY

La clause ORDER BY trie le résultat de la requête. Le code suivant présente la syntaxe :

SELECT 
	column1, column2, ... , columnN
FROM 
	table_name
ORDER BY 
	column1, column2, .. columnN ASC | DESC;

ASC effectue un tri croissant ; DESC effectue un tri décroissant. Si vous omettez la direction de tri, l'ordre par défaut est croissant.

Chaque direction de tri s'applique uniquement à la colonne qui la suit immédiatement. Par exemple, ORDER BY column1, column2 DESC trie d'abord par column1 dans l'ordre croissant, puis par column2 dans l'ordre décroissant pour les lignes ayant la même valeur de column1. ORDER BY column1 DESC, column2 DESC trie les deux colonnes dans l'ordre décroissant.

Triez par une ou plusieurs colonnes, y compris celles qui ne figurent pas dans la liste SELECT. Lorsque plusieurs colonnes sont spécifiées, le résultat est d'abord trié par la première colonne. Pour les lignes ayant des valeurs identiques dans la première colonne, le résultat est ensuite trié par la deuxième colonne.

Lorsque vous choisissez des colonnes pour ORDER BY, tenez compte des points suivants :

• Évitez de trier par des colonnes contenant des valeurs NULL. Sans traitement spécial, le tri des ressources est incorrect lorsqu'une colonne contient des valeurs NULL.

• Si la colonne de tri contient des valeurs en double, la même instruction SELECT peut renvoyer des résultats différents lors d'exécutions répétées. Ajoutez une colonne de tri secondaire pour garantir des résultats cohérents.

Par exemple, triez les ressources d'abord par type de ressource, puis par ID de ressource au sein de chaque type :

SELECT
	resource_id,
	resource_name,
	region_id,
	zone_id,
	resource_type,
	account_id
FROM
	resources
ORDER BY
	resource_type,
	resource_id;

GROUP BY

La clause GROUP BY groupe le résultat de la requête selon une ou plusieurs colonnes. Pour chaque groupe, appliquez des fonctions d'agrégation telles que COUNT, SUM ou AVG pour calculer des statistiques. Le code suivant présente la syntaxe :

SELECT 
	column1, column2, ... , columnN
FROM 
	table_name
WHERE 
	[ conditions ]
GROUP BY 
	column1, column2....columnN
ORDER BY 
	column1, column2....columnN

La clause GROUP BY doit apparaître après la clause WHERE (le cas échéant) et avant la clause ORDER BY (le cas échéant). Toutes les colonnes de la clause GROUP BY doivent également figurer dans la liste SELECT ; sinon, une erreur est renvoyée.

Par exemple, groupez les ressources par type de ressource et comptez chaque type. Étant donné que le résultat ne contient qu'une colonne de chaîne et une colonne numérique, la recherche avancée peut le rendre sous forme de graphique :

SELECT
 	resource_type,
 	COUNT(*) AS cnt
FROM
 	resources
GROUP BY
 	resource_type
ORDER BY
 	cnt DESC;

LIMIT

La clause LIMIT limite le nombre de lignes renvoyées. Utilisez-la conjointement avec OFFSET pour contrôler les lignes renvoyées :

LIMIT 
	count OFFSET start

Le code suivant présente la syntaxe complète combinant LIMIT et OFFSET :

SELECT 
	column1, column2, ... , columnN 
FROM 
	table_name 
LIMIT 
	[no of rows] OFFSET [row num]

LIMIT 10 renvoie un maximum de 10 lignes. OFFSET 10 démarre le résultat à partir de la 11e ligne de la table source. Sans OFFSET, le résultat commence à partir de la première ligne.

Une requête dans la recherche avancée renvoie au maximum 1 000 lignes. Pour les grands ensembles de données, utilisez LIMIT avec OFFSET pour paginer les résultats. Combinez toujours LIMIT avec ORDER BY pour garantir des lignes consécutives et cohérentes d'une page à l'autre.

Par exemple, renvoyez les 20 premières ressources triées par ID de ressource dans l'ordre décroissant :

SELECT
	resource_id,
	resource_name,
	region_id,
	resource_type,
	account_id
FROM
	resources
ORDER BY
	resource_id DESC
LIMIT
	20;

Par exemple, récupérez les lignes 1001 à 2000 triées par ID de ressource dans l'ordre décroissant :

SELECT
 	resource_id,
 	resource_name,
 	region_id,
 	resource_type,
 	account_id
FROM
 	resources
ORDER BY
 	resource_id DESC
LIMIT
 	1000 OFFSET 1000;