web/wdoc/tut_rql_fr.rst
changeset 0 b97547f5f1fa
child 1398 5fe84a5f7035
equal deleted inserted replaced
-1:000000000000 0:b97547f5f1fa
       
     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 (EUser)`, relation vers l'utilisateur ayant créé l'entité
       
   138 
       
   139 * `owned_by (EUser)`, 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 :EUser:
       
   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