Référence pour les requêtes eXtreme Scale

WebSphere eXtreme Scale possède son propre langage à l'aide duquel l'utilisateur peut interroger les données.

Clause FROM de requête ObjectGrid

La *clause FROM indique les collections d'objets auxquels la requête doit être appliquée. Chaque collection est identifiée par un nom de schéma abstrait et une variable d'identification, appelée variable de plage, ou par une déclaration de membre de collection qui identifie une relation à valeur unique ou à plusieurs valeurs et une variable d'identification.

D'une manière conceptuelle, la sémantique de la requête consiste à former d'abord une collection temporaire de nuplets, appelée R. Les nuplets sont composés d'éléments des collections identifiées dans la clause FROM. Chaque nuplet contient un élément de chacune des collections de la clause FROM. Toutes les combinaisons possibles sont constituées en fonction des contraintes imposées par les déclarations de membre de collection. Si un nom de schéma identifie une collection pour laquelle il n'existe pas d'enregistrements dans le stockage de persistance, la collection temporaire R est vide.

Exemples d'utilisation de la clause FROM

L'objet DeptBean contient les enregistrements 10, 20 et 30. L'objet EmpBean contient les enregistrements 1, 2 et 3 relatifs à la division 10 et les enregistrements 4 et 5 relatifs à la division 20. La division 30 n'est associée à aucun employé.

FROM DeptBean d, EmpBean e

Cette clause constitue une collection temporaire R qui contient 15 nuplets.

FROM DeptBean d, DeptBean d1

Cette clause constitue une collection temporaire R qui contient 9 nuplets.

FROM DeptBean d, IN (d.emps) AS e

Cette clause constitue une collection temporaire R qui contient 5 nuplets. La division 30 ne se trouve pas dans la collecte temporaire R car elle ne contient aucun employé. La division 10 se trouve trois fois dans la collection temporaire R et la division 20 s'y trouve deux fois.

Au lieu d'utiliser IN(d.emps) as e, vous pouvez utiliser un prédicat JOIN :

FROM DeptBean d JOIN d.emps as e

Une fois la collection temporaire formée, les conditions de recherche de la clause WHERE sont appliquées à la collection temporaire R et renvoient une nouvelle collection temporaire R1. Les clauses ORDER BY et SELECT sont appliquées à R1 pour renvoyer l'ensemble de résultats final.

Une variable d'identification est une variable déclarée dans la clause FROM à l'aide de l'opérateur IN ou de l'opérateur facultatif AS.

FROM DeptBean AS d, IN (d.emps) AS e

équivaut à :

FROM DeptBean d, IN (d.emps) e

Une variable d'identification déclarée comme nom de schéma abstrait est appelée variable de plage. Dans la requête précédente, "d" est une variable de plage. Une variable d'identification déclarée comme expression de chemin à plusieurs valeurs est appelée déclaration de membre de collection. Les variables "d" et "e" de l'exemple précédent sont des déclarations de membre de collection.

Voici un exemple d'utilisation d'une expression de chemin à valeur unique dans la clause FROM :

FROM EmpBean e, IN(e.dept.mgr) as m

Clause SELECT de requête ObjectGrid

La syntaxe de la clause SELECT est illustrée dans l'exemple suivant :

SELECT { ALL | DISTINCT } [ selection , ]* selection

selection  ::= {single_valued_path_expression |
                variable_identification |  OBJECT ( variable_identification) |
	       aggregate_functions } [[ AS ] id ]

La clause SELECT se compose d'un ou plusieurs des éléments suivants : une variable d'identification définie dans la clause FROM, une expression de chemin d'accès à valeur unique ayant pour résultat des références d'objet ou des valeurs et une fonction d'agrégation. Vous pouvez utiliser le mot clé DISTINCT pour éliminer les références en double.

Une sous-requête scalaire est une sous-requête qui ne renvoie qu'une valeur.

Exemples d'utilisation de la clause SELECT

Pour trouver tous les employés qui touchent plus que l'employé Jean :

SELECT OBJECT(e) FROM EmpBean ej, EmpBean eWHERE ej.name = 'John' and e.salary > ej.salary

Trouver toutes les divisions ayant un ou plusieurs employés dont le salaire est inférieur à 20000 :

SELECT DISTINCT e.dept FROM EmpBean e where e.salary < 20000

Une requête peut avoir une expression de chemin d'accès qui a pour résultat une valeur arbitraire :

SELECT e.dept.name FROM EmpBean e where e.salary < 20000

La requête précédente renvoie une collection de noms des divisions ayant des employés dont le salaire est inférieur à 20000.

Une requête peut renvoyer une valeur agrégée :

SELECT avg(e.salary) FROM EmpBean e

Voici une requête qui extrait les noms et les références d'objet pour les employés sous-payés :

SELECT e.name as name , object(e) as emp from EmpBean e where e.salary < 50000

Clause WHERE de requête ObjectGrid

La clause WHERE contient des conditions de recherche composées des éléments présentés ci-après. Si une condition de recherche a pour résultat TRUE, le bloc de données est ajouté à l'ensemble de résultats.

Littéraux de requête ObjectGrid

Un littéral chaîne est indiqué entre apostrophe. Une apostrophe apparaissant dans un littéral chaîne doit être doublée. Par exemple : 'Tom''s'.

Un littéral numérique peut être de l'une des valeurs suivantes :

  • Une valeur exacte, telle que 57, -957 ou +66
  • Toute valeur prise en charge par le type Java long
  • Un littéral décimal, tel que 57,5 ou -47,02
  • Une valeur numérique approchée, telle que 7E3 ou -57,4E-2
  • Les types float doivent inclure le qualificateur "F". Par exemple : 1.0F
  • Les types long doivent inclure le qualificateur "L". Par exemple : 123L

Les littéraux booléens sont TRUE et FALSE.

Les littéraux temporaux respectent la syntaxe d'échappement de JDBC en fonction du type d'attribut :

  • java.util.Date: aaaa-mm-ss
  • java.sql.Date: aaaa-mm-ss
  • java.sql.Time: hh-mm-ss
  • java.sql.Timestamp: aaaa-mm-jj hh:mm:ss.f...
  • java.util.Calendar: aaaa-mm-jj hh:mm:ss.f...

Les littéraux d'énumération sont exprimés à l'aide de la syntaxe des littéraux d'énumération Java et du nom complet de la classe enum.

Paramètres d'entrée de requête ObjectGrid

Vous pouvez spécifier des paramètres d'entrée à l'aide d'une position ordinale ou d'un nom de variable. La génération de requêtes qui utilisent des paramètres d'entrée est fortement recommandée, car l'utilisation de paramètres d'entrée augmente les performances en permettant à l'ObjectGrid d'intercepter le plan de requête entre les actions d'exécution.

Un paramètre d'entrée peut être de l'un des types suivants : Byte, Short, Integer, Long, Float, Double, BigDecimal, BigInteger, String, Boolean, Char, java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp, java.util.Calendar, une énumération Java SE 5, une entité ou un objet Java simple ou une chaîne de données binaires au format Java byte[].

Un paramètre d'entrée ne doit pas avoir une valeur NULL. Pour rechercher une valeur NULL, utilisez le prédicat NULL.

Paramètres positionnels

Les paramètres d'entrée positionnels sont définis à l'aide d'un point d'interrogation suivi d'un nombre positif :

?[positive integer].

Les paramètres d'entrée positionnels sont numérotés à partir de 1 et correspondent aux arguments de la requête ; en conséquence, une requête ne doit pas contenir de paramètre d'entrée dont le numéro est supérieur au nombre d'arguments d'entrée.

Exemple : SELECT e FROM Employee e WHERE e.city = ?1 and e.salary >= ?2

Paramètres de nom

Les paramètres d'entrée de nom sont définis à l'aide d'un nom de variable au format : :[nom du paramètre].

Exemple : SELECT e FROM Employee e WHERE e.city = :city and e.salary >= :salary

Prédicat BETWEEN de requête ObjectGrid

Le prédicat BETWEEN détermine si une valeur donnée est comprise entre deux autres valeurs données.

expression [NOT] BETWEEN expression-2 AND expression-3

Exemple 1

e.salary BETWEEN 50000 AND 60000

équivaut à :

e.salary >= 50000 AND e.salary <= 60000

Exemple 2

e.name NOT BETWEEN 'A' AND 'B'

équivaut à :

e.name < 'A' OR e.name > 'B'

Prédicat IN de requête ObjectGrid

Le prédicat IN compare une valeur à une série de valeurs. Vous pouvez utiliser le prédicat IN sous deux formes :

expression [NOT] IN ( subselect )expression [NOT] IN ( value1, value2, .... )

La valeur ValueN peut être une valeur littérale ou un paramètre d'entrée. L'expression ne peut pas avoir une référence pour résultat.

Exemple 1

e.salary IN ( 10000, 15000 )

équivaut à :

( e.salary = 10000 OR e.salary = 15000 )

Exemple 2

e.salary IN ( select e1.salary from EmpBean e1 where e1.dept.deptno = 10)

équivaut à :

e.salary = ANY ( select e1.salary from EmpBean e1 where e1.dept.deptno = 10)

Exemple 3

e.salary NOT IN ( select e1.salary from EmpBean e1 where e1.dept.deptno = 10)

équivaut à :

e.salary <> ALL ( select e1.salary from EmpBean e1 where e1.dept.deptno = 10)

Prédicat LIKE de requête ObjectGrid

Le prédicat LIKE recherche une valeur de chaîne pour un modèle particulier.

expression-chaîne [NOT] LIKE pattern [ ESCAPE caractère-échappement ]

La valeur de modèle est un littéral chaîne ou un marqueur de paramètre de chaîne de type dans lequel le soulignement ( _ ) remplace tout caractère et le signe pourcentage ( % ) toute séquence de caractères, y compris une séquence vide). Tout autre caractère correspond à lui même. Le caractère d'échappement permet de rechercher les caractères _ et %. Il peut être indiqué en tant que littéral chaîne ou paramètre d'entrée.

Si l'expression de chaîne est nulle, le résultat est inconnu.

Si l'expression de chaîne et le modèle nuls, le résultat est vrai.

Exemple

'' LIKE '' is true
'' LIKE '%' is true
e.name LIKE '12%3' is true for '123' '12993' and false for '1234'
e.name LIKE 's_me' is true for 'some' and 'same', false for 'soome'
e.name LIKE '/_foo' escape '/' is true for '_foo', false for 'afoo'
e.name LIKE '//_foo' escape '/' is true for '/afoo' and for '/bfoo'
e.name LIKE '///_foo' escape '/' is true for '/_foo' but false for '/afoo'

Prédicat NULL de requête ObjectGrid

Le prédicat NULL recherche les valeurs nulles (NULL).

{single-valued-path-expression | input_parameter} IS [NOT] NULL

Exemple

e.name IS NULL
e.dept.name IS NOT NULL
e.dept IS NOT NULL

Prédicat de collection EMPTY de requête ObjectGrid

Utilisez le prédicat de collection EMPTY pour vérifier si une collection est vide.

Pour vérifier si une relation à plusieurs valeurs est vide, utilisez la syntaxe suivante :

expression-chemin-valorisé-collection IS [NOT] EMPTY

Exemple

Prédicat de collection empty Permet de rechercher toutes les divisions ne possédant pas d'employés :

SELECT OBJECT(d) FROM DeptBean d WHERE d.emps IS EMPTY

Prédicat MEMBER OF de requête ObjectGrid

L'expression ci-après vérifie si la référence d'objet indiquée par l'expression de chemin d'accès à valeur unique ou le paramètre d'entrée fait partie de la collection désignée. Si l'expression de chemin d'accès valorisée de la collection désigne une collection vide, la valeur de l'expression MEMBER OF est FALSE.

{ expression-chemin-valeur-unique | paramètre_entrée } [ NOT ] MEMBER [ OF ] expression-chemin-valorisée-collection

Exemple

Trouver les employés qui n'appartiennent pas à une division donnée :

SELECT OBJECT(e) FROM
EmpBean e , DeptBean d 
WHERE e NOT MEMBER OF d.emps AND d.deptno = ?1
Trouver les employés dont le responsable appartient à une division donnée :
SELECT OBJECT(e) FROM EmpBean e,
DeptBean d 
WHERE e.dept.mgr MEMBER  OF d.emps  and d.deptno=?1

Prédicat EXISTS de requête ObjectGrid

Le prédicat EXISTS vérifie la présence ou l'absence d'une condition spécifiée par une sous-requête.

EXISTS ( sous-requête )

Le résultat d'EXISTS est true si la sous-requête renvoie au moins une valeur ; sinon le résultat est false.

Pour inverser un prédicat EXISTS, faites-le précéder de l'opérateur logique NOT.

Exemple

Pour renvoyer les divisions dont l'un des employés au moins a un salaire supérieur à 1000000 :

SELECT OBJECT(d) FROM DeptBean d 
WHERE EXISTS ( SELECT  e  FROM IN (d.emps) e WHERE  e.salary > 1000000 )
Pour renvoyer les divisions sans employés :
SELECT OBJECT(d) FROM DeptBean d 
WHERE NOT EXISTS  ( SELECT e FROM IN (d.emps) e)
Vous pouvez également modifier la requête précédente conformément à l'exemple suivant :

SELECT OBJECT(d) FROM DeptBean d WHERE SIZE(d.emps)=0

Clause ORDER BY de requête ObjectGrid

La clause ORDER BY spécifie l'ordre de classement des objets dans la collection résultante. Voici un exemple :

ORDER BY [ order_element ,]* order_element order_element ::={ path-expression }[ ASC | DESC ]

L'expression de chemin d'accès doit indiquer une zone à valeur unique de type primitif byte, short, int, long, float, double, char ou de type encapsuleur Byte, Short, Integer, Long, Float, Double, BigDecimal, String, Character, java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp ou java.util.Calendar. L'élément de classement ASC indique que les résultats sont affichés dans l'ordre croissant, qui correspond à la valeur par défaut. Un élément de classement DESC indique que les résultats sont affichés dans l'ordre décroissant.

Exemple

Renvoyez les objets division. Affichez les numéros des divisions par ordre décroissant :

SELECT OBJECT(d) FROM DeptBean d ORDER BY d.deptno DESC

Pour renvoyer les objets employés, triés par numéro de division et par nom :

SELECT  OBJECT(e) FROM EmpBean e ORDER BY e.dept.deptno ASC,  e.name DESC

Fonctions d'agrégation de requête ObjectGrid

Les fonctions d'agrégation opèrent sur une série de valeurs pour renvoyer une valeur scalaire. Vous pouvez utiliser ces fonctions dans les méthodes de sélection et de sous-requête. Voici un exemple d'agrégation :

SELECT SUM (e.salary) FROM EmpBean e WHERE e.dept.deptno =20

Cette agrégation calcule le total des salaires de la division 20.

Les fonctions d'agrégation sont AVG, COUNT, MAX, MIN et SUM. La syntaxe d'une fonction d'agrégation est illustrée dans l'exemple suivant :

fonction-agrégation ( [ ALL | DISTINCT ] expression )

ou :

COUNT( [ ALL | DISTINCT ] identification-variable )

L'option DISTINCT supprime les valeurs en double avant d'exécuter la fonction. L'option ALL est l'option par défaut qui ne supprime pas les valeurs en double. Les valeurs NULL sont ignorées lors du traitement de la fonction d'agrégation sauf si vous utilisez la fonction COUNT(identification-variable), qui renvoie le total de tous les éléments que contient la série.

Définition du type de retour

Les fonctions MAX et MIN peuvent s'appliquer à tout type de données numérique, chaîne ou de date et d'heure et renvoient le type de données correspondant. Les fonctions SUM et AVG acceptent un type numérique en entrée. La fonction AVG renvoie un type double. La fonction SUM renvoie un type long si l'entrée correspond à un entier, sauf s'il s'agit d'un type Java BigInteger. Dans ce cas, la fonction renvoie un type Java BigInteger. La fonction SUM renvoie un type double si l'entrée ne correspond pas à un entier, sauf s'il s'agit d'un type Java BigDecimal. Dans ce cas, la fonction renvoie un type Java BigDecimal. La fonction COUNT peut accepter n'importe quel type de données, à part les collections, et renvoie un type long.

Lorsqu'elles s'appliquent à un ensemble vide, les fonctions SUM, AVG, MAX et MIN peuvent renvoyer une valeur null. La fonction COUNT renvoie zéro (0) lorsqu'elle est appliquée à un ensemble vide.

Utilisation des clauses GROUP BY et HAVING

La série de valeurs utilisée pour la fonction d'agrégation est déterminée par la collection résultant de la clause FROM et WHERE de la requête. Vous pouvez diviser la série en groupes et appliquer la fonction d'agrégation à chaque groupe. Pour exécuter cette action, utilisez une clause GROUP BY dans la requête. Cette clause définit les membres des groupes, ce qui comprend une liste d'expressions de chemin d'accès. Chaque expression de chemin d'accès désigne une zone de type primitif byte, short, int, long, float, double, boolean ou char, ou de type encapsuleur Byte, Short, Integer, Long, Float, Double, BigDecimal, String, Boolean, Character, java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp, java.util.Calendar ou enum Java SE 5.

L'exemple suivant illustre l'utilisation de la clause GROUP BY dans une requête qui calcule le salaire moyen pour chaque division :

SELECT e.dept.deptno, AVG ( e.salary) FROM EmpBean e GROUP BY e.dept.deptno

Lorsque vous divisez une série en groupes, une valeur NULL est considérée comme étant égale à une autre valeur NULL.

Les groupes peuvent être filtrés à l'aide d'une clause HAVING qui teste les propriétés des groupes avant de faire appel à des fonctions d'agrégation ou de regrouper les membres. Ce filtrage est similaire au filtrage des nuplets (c'est-à-dire, des enregistrements des valeurs des collections renvoyées) de la clause FROM par la clause WHERE. Voici un exemple de clause HAVING :

SELECT e.dept.deptno,  AVG ( e.salary) FROM EmpBean e
GROUP BY e.dept.deptno
HAVING COUNT(e) > 3 AND e.dept.deptno > 5
Cette requête renvoie le salaire moyen des divisions ayant plus de trois employés et dont le numéro de division est supérieur à cinq.

Vous pouvez utiliser une clause HAVING sans clause GROUP BY. Dans ce cas, la totalité de la série est traitée comme un seul et même groupe auquel est appliquée la clause HAVING.