|
1 .. -*- coding: utf-8 -*- |
|
2 |
|
3 Apprenons RQL par la pratique... |
|
4 |
|
5 .. contents:: |
|
6 |
|
7 |
|
8 Introduction |
|
9 ------------ |
|
10 |
|
11 RQL est assez proche par sa syntaxe et ses principes du langage de requête des |
|
12 bases de données relationnelles SQL. Il est cependant plus intuitif et mieux |
|
13 adapté pour faire des recherches avancées sur des bases de données structurées |
|
14 par un schéma de données. On retiendra les points suivants : |
|
15 |
|
16 * RQL est un langage mettant l'accent sur le parcours de relations. |
|
17 * Les attributs sont considérés comme des cas particuliers de relations. |
|
18 * RQL s'inspire de SQL mais se veut plus haut niveau. |
|
19 * Une connaissance du schéma définissant l'application est nécessaire. |
|
20 |
|
21 Pour s'en servir, il convient de connaître les règles de base du langage RQL, |
|
22 mais surtout d'avoir une bonne vision du schéma de données de l'application. Ce |
|
23 schéma est toujours disponible dans l'application par le lien `schéma`, dans la |
|
24 boîte affichée en cliquant sur le lien de l'utilisateur connectée (en haut à droite). |
|
25 Vous pouvez également le voir en cliquant ici_. |
|
26 |
|
27 .. _ici: ../schema |
|
28 |
|
29 |
|
30 Un peu de théorie |
|
31 ----------------- |
|
32 |
|
33 Variables et typage |
|
34 ~~~~~~~~~~~~~~~~~~~ |
|
35 Les entités et valeurs à parcourir et / ou séléctionner sont représentées dans |
|
36 la requête par des *variables* qui doivent être écrites en majuscule |
|
37 |
|
38 Les types possibles pour chaque variable sont déduits à partir du schéma en |
|
39 fonction des contraintes présentes dans la requête. |
|
40 |
|
41 On peut contraindre les types possibles pour une variable à l'aide de la |
|
42 relation spéciale `is`. |
|
43 |
|
44 Types de bases |
|
45 ~~~~~~~~~~~~~~ |
|
46 * `String` (litéral: entre doubles ou simples quotes) |
|
47 * `Int`, `Float` (le séparateur étant le '.') |
|
48 * `Date`, `Datetime`, `Time` (litéral: chaîne YYYY/MM/DD[ hh:mm] ou mots-clés |
|
49 `TODAY` et `NOW`) |
|
50 * `Boolean` (mots-clés `TRUE` et `FALSE`) |
|
51 * mot-clé `NULL` |
|
52 |
|
53 Opérateurs |
|
54 ~~~~~~~~~~ |
|
55 * Opérateurs logiques : `AND`, `OR`, `,` |
|
56 * Opérateurs mathématiques: `+`, `-`, `*`, `/` |
|
57 * Operateur de comparaisons: `=`, `<`, `<=`, `>=`, `>`, `~=`, `LIKE`, `IN` |
|
58 |
|
59 * L'opérateur `=` est l'opérateur par défaut |
|
60 |
|
61 * L'opérateur `LIKE` / `~=` permet d'utiliser le caractère `%` dans une chaine |
|
62 de caractère pour indiquer que la chaîne doit commencer ou terminer par un |
|
63 préfix/suffixe :: |
|
64 |
|
65 Any X WHERE X nom ~= 'Th%' |
|
66 Any X WHERE X nom LIKE '%lt' |
|
67 |
|
68 * L'opérateur `IN` permet de donner une liste de valeurs possibles :: |
|
69 |
|
70 Any X WHERE X nom IN ('chauvat', 'fayolle', 'di mascio', 'thenault') |
|
71 |
|
72 Grammaire des requêtes de recherche |
|
73 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|
74 :: |
|
75 |
|
76 [DISTINCT] <type d'entité> V1(, V2)* |
|
77 [GROUPBY V1(, V2)*] [ORDERBY <orderterms>] |
|
78 [WHERE <restriction>] |
|
79 [LIMIT <value>] [OFFSET <value>] |
|
80 |
|
81 :type d'entité: |
|
82 Type de la ou des variables séléctionnées. |
|
83 Le type spécial `Any`, revient à ne pas spécifier de type. |
|
84 :restriction: |
|
85 liste des relations à parcourir sous la forme |
|
86 `V1 relation V2|<valeur constante>` |
|
87 :orderterms: |
|
88 Définition de l'ordre de sélection : variable ou n° de colonne suivie de la |
|
89 méthode de tri (`ASC`, `DESC`), ASC étant la valeur par défaut |
|
90 |
|
91 note pour les requêtes groupées (i.e. avec une clause `GROUPBY`) : |
|
92 toutes les variables sélectionnées doivent être soit groupée soit |
|
93 aggrégée |
|
94 |
|
95 |
|
96 Schéma |
|
97 ------ |
|
98 |
|
99 Nous supposerons dans la suite de ce document que le schéma de l'application est |
|
100 le suivant. Les différentes entités disponibles sont : |
|
101 |
|
102 :Personne: |
|
103 :: |
|
104 |
|
105 nom (String, obligatoire) |
|
106 datenaiss (Date) |
|
107 |
|
108 |
|
109 :Societe: |
|
110 :: |
|
111 |
|
112 nom (String) |
|
113 |
|
114 |
|
115 :Note: |
|
116 :: |
|
117 |
|
118 diem (Date) |
|
119 type (String) |
|
120 |
|
121 |
|
122 Et les relations entre elles : :: |
|
123 |
|
124 Person travaille_pour Societe |
|
125 Person evaluee_par Note |
|
126 Societe evaluee_par Note |
|
127 |
|
128 |
|
129 Méta-données |
|
130 ~~~~~~~~~~~~ |
|
131 Tous les types d'entités ont les métadonnées suivantes : |
|
132 |
|
133 * `eid (Int)`, permettant d'identifier chaque instance de manière unique |
|
134 * `creation_date (Datetime)`, date de création de l'entité |
|
135 * `modification_date (Datetime)`, date de dernière modification de l'entité |
|
136 |
|
137 * `created_by (CWUser)`, relation vers l'utilisateur ayant créé l'entité |
|
138 |
|
139 * `owned_by (CWUser)`, relation vers le où les utilisateurs considérés comme |
|
140 propriétaire de l'entité, par défaut le créateur de l'entité |
|
141 |
|
142 * `is (Eetype)`, relation spéciale permettant de spécifier le |
|
143 type d'une variable. |
|
144 |
|
145 Enfin, le schéma standard d'un utilisateur est le suivant : |
|
146 |
|
147 :CWUser: |
|
148 :: |
|
149 |
|
150 login (String, obligatoire) |
|
151 password (Password) |
|
152 firstname (String) |
|
153 surname (String) |
|
154 |
|
155 |
|
156 L'essentiel |
|
157 ----------- |
|
158 0. *Toutes les personnes* :: |
|
159 |
|
160 Personne X |
|
161 |
|
162 ou :: |
|
163 |
|
164 Any X WHERE X is Personne |
|
165 |
|
166 |
|
167 1. *La societé nommé Logilab* :: |
|
168 |
|
169 Societe S WHERE S nom 'Logilab' |
|
170 |
|
171 |
|
172 2. *Toutes les entités ayant un attribut nom commençant par 'Log'* :: |
|
173 |
|
174 Any S WHERE S nom LIKE 'Log%' |
|
175 |
|
176 ou :: |
|
177 |
|
178 Any S WHERE S nom ~= 'Log%' |
|
179 |
|
180 Cette requête peut renvoyer des entités de type personne et de type |
|
181 société. |
|
182 |
|
183 |
|
184 3. *Toutes les personnes travaillant pour la société nommé Logilab* :: |
|
185 |
|
186 Personne P WHERE P travaille_pour S, S nom "Logilab" |
|
187 |
|
188 ou :: |
|
189 |
|
190 Personne P WHERE P travaille_pour S AND S nom "Logilab" |
|
191 |
|
192 |
|
193 4. *Les societés nommées Caesium ou Logilab* :: |
|
194 |
|
195 Societe S WHERE S nom IN ('Logilab','Caesium') |
|
196 |
|
197 ou :: |
|
198 |
|
199 Societe S WHERE S nom 'Logilab' OR S nom 'Caesium' |
|
200 |
|
201 |
|
202 5. *Toutes les societés sauf celles nommées Caesium ou Logilab* :: |
|
203 |
|
204 Societe S WHERE NOT S nom IN ('Logilab','Caesium') |
|
205 |
|
206 ou :: |
|
207 |
|
208 Societe S WHERE NOT S nom 'Logilab' AND NOT S nom 'Caesium' |
|
209 |
|
210 |
|
211 6. *Les entités évalués par la note d'identifiant 43* :: |
|
212 |
|
213 Any X WHERE X evaluee_par N, N eid 43 |
|
214 |
|
215 |
|
216 7. *Toutes les personnes triés par date de naissance dans l'ordre antechronologique* :: |
|
217 |
|
218 Personne X ORDERBY D DESC WHERE X datenaiss D |
|
219 |
|
220 On note qu'il faut définir une variable et la séléctionner pour s'en |
|
221 servir pour le tri. |
|
222 |
|
223 |
|
224 8. *Nombre de personne travaillant pour chaque société* :: |
|
225 |
|
226 Any S, COUNT(X) GROUPBY S WHERE X travaille_pour S |
|
227 |
|
228 On note qu'il faut définir une variable pour s'en servir pour le |
|
229 groupage. De plus les variables séléctionnée doivent être groupée |
|
230 (mais les variables groupées ne doivent pas forcément être sélectionnées). |
|
231 |
|
232 |
|
233 |
|
234 Exemples avancés |
|
235 ---------------- |
|
236 0. *Toutes les personnes dont le champ nom n'est pas spécifié (i.e NULL)* :: |
|
237 |
|
238 Personne P WHERE P nom NULL |
|
239 |
|
240 |
|
241 1. *Toutes les personnes ne travaillant pour aucune société* :: |
|
242 |
|
243 Personne P WHERE NOT p travaille_pour S |
|
244 |
|
245 |
|
246 2. *Toutes les sociétés où la personne nommée toto ne travaille pas* :: |
|
247 |
|
248 Societe S WHERE NOT P travaille_pour S , P nom 'toto' |
|
249 |
|
250 |
|
251 3. *Toutes les entités ayant été modifiées entre aujourd'hui et hier* :: |
|
252 |
|
253 Any X WHERE X modification_date <= TODAY, X modification_date >= TODAY - 1 |
|
254 |
|
255 |
|
256 4. *Toutes les notes n'ayant pas de type et à effectuer dans les 7 jours, triées par date* :: |
|
257 |
|
258 Any N, D where N is Note, N type NULL, N diem D, N diem >= TODAY, |
|
259 N diem < today + 7 ORDERBY D |
|
260 |
|
261 |
|
262 5. *Les personnes ayant un homonyme (sans doublons)* :: |
|
263 |
|
264 DISTINCT Personne X,Y where X nom NX, Y nom NX |
|
265 |
|
266 ou mieux (sans avoir (Xeid, Yeid) et (Yeid, Xeid) dans les résultats) :: |
|
267 |
|
268 Personne X,Y where X nom NX, Y nom NX, X eid XE, Y eid > XE |