Tutoriel "Relation Query Language"

Apprenons RQL par la pratique...

Introduction

RQL est assez proche par sa syntaxe et ses principes du langage de requête des bases de données relationnelles SQL. Il est cependant plus intuitif et mieux adapté pour faire des recherches avancées sur des bases de données structurées par un schéma de données. On retiendra les points suivants :

  • RQL est un langage mettant l'accent sur le parcours de relations.
  • Les attributs sont considérés comme des cas particuliers de relations.
  • RQL s'inspire de SQL mais se veut plus haut niveau.
  • Une connaissance du schéma définissant l'application est nécessaire.

Pour s'en servir, il convient de connaître les règles de base du langage RQL, mais surtout d'avoir une bonne vision du schéma de données de l'application. Ce schéma est toujours disponible dans l'application par le lien schéma, dans la boîte affichée en cliquant sur le lien de l'utilisateur connectée (en haut à droite). Vous pouvez également le voir en cliquant ici.

Un peu de théorie

Variables et typage

Les entités et valeurs à parcourir et / ou séléctionner sont représentées dans la requête par des variables qui doivent être écrites en majuscule

Les types possibles pour chaque variable sont déduits à partir du schéma en fonction des contraintes présentes dans la requête.

On peut contraindre les types possibles pour une variable à l'aide de la relation spéciale is.

Types de bases

  • String (litéral: entre doubles ou simples quotes)
  • Int, Float (le séparateur étant le '.')
  • Date, Datetime, Time (litéral: chaîne YYYY/MM/DD[ hh:mm] ou mots-clés TODAY et NOW)
  • Boolean (mots-clés TRUE et FALSE)
  • mot-clé NULL

Opérateurs

  • Opérateurs logiques : AND, OR, ,

  • Opérateurs mathématiques: +, -, *, /

  • Operateur de comparaisons: =, <, <=, >=, >, ~=, LIKE, IN

    • L'opérateur = est l'opérateur par défaut

    • L'opérateur LIKE / ~= permet d'utiliser le caractère % dans une chaine de caractère pour indiquer que la chaîne doit commencer ou terminer par un préfix/suffixe

      Any X WHERE X nom ~= 'Th%'
      Any X WHERE X nom LIKE '%lt'
      
    • L'opérateur IN permet de donner une liste de valeurs possibles

      Any X WHERE X nom IN ('chauvat', 'fayolle', 'di mascio', 'thenault')
      

Grammaire des requêtes de recherche

[DISTINCT] <type d'entité> V1(, V2)*
[GROUPBY V1(, V2)*]  [ORDERBY <orderterms>]
[WHERE <restriction>]
[LIMIT <value>] [OFFSET <value>]
type d'entité:

Type de la ou des variables séléctionnées. Le type spécial Any, revient à ne pas spécifier de type.

restriction:
liste des relations à parcourir sous la forme

V1 relation V2|<valeur constante>

orderterms:

Définition de l'ordre de sélection : variable ou n° de colonne suivie de la méthode de tri (ASC, DESC), ASC étant la valeur par défaut

note pour les requêtes groupées (i.e. avec une clause GROUPBY) : toutes les variables sélectionnées doivent être soit groupée soit aggrégée

Schéma

Nous supposerons dans la suite de ce document que le schéma de l'application est le suivant. Les différentes entités disponibles sont :

Personne:
nom    (String, obligatoire)
datenaiss (Date)
Societe:
nom   (String)
Note:
diem (Date)
type (String)

Et les relations entre elles :

Person  travaille_pour Societe
Person  evaluee_par    Note
Societe evaluee_par    Note

Méta-données

Tous les types d'entités ont les métadonnées suivantes :

  • eid (Int), permettant d'identifier chaque instance de manière unique
  • creation_date (Datetime), date de création de l'entité
  • modification_date (Datetime), date de dernière modification de l'entité
  • created_by (CWUser), relation vers l'utilisateur ayant créé l'entité
  • owned_by (CWUser), relation vers le où les utilisateurs considérés comme propriétaire de l'entité, par défaut le créateur de l'entité
  • is (Eetype), relation spéciale permettant de spécifier le type d'une variable.

Enfin, le schéma standard d'un utilisateur est le suivant :

CWUser:
login     (String, obligatoire)
password  (Password)
firstname (String)
surname   (String)

L'essentiel

  1. Toutes les personnes

    Personne X
    

    ou

    Any X WHERE X is Personne
    
  2. La societé nommé Logilab

    Societe S WHERE S nom 'Logilab'
    
  3. Toutes les entités ayant un attribut nom commençant par 'Log'

    Any S WHERE S nom LIKE 'Log%'
    

    ou

    Any S WHERE S nom ~= 'Log%'
    

    Cette requête peut renvoyer des entités de type personne et de type société.

  4. Toutes les personnes travaillant pour la société nommé Logilab

    Personne P WHERE P travaille_pour S, S nom "Logilab"
    

    ou

    Personne P WHERE P travaille_pour S AND S nom "Logilab"
    
  5. Les societés nommées Caesium ou Logilab

    Societe S WHERE S nom IN ('Logilab','Caesium')
    

    ou

    Societe S WHERE S nom 'Logilab' OR S nom 'Caesium'
    
  6. Toutes les societés sauf celles nommées Caesium ou Logilab

    Societe S WHERE NOT S nom IN ('Logilab','Caesium')
    

    ou

    Societe S WHERE NOT S nom 'Logilab' AND NOT S nom 'Caesium'
    
  7. Les entités évalués par la note d'identifiant 43

    Any X WHERE X evaluee_par N, N eid 43
    
  8. Toutes les personnes triés par date de naissance dans l'ordre antechronologique

    Personne X ORDERBY D DESC WHERE X datenaiss D
    

    On note qu'il faut définir une variable et la séléctionner pour s'en servir pour le tri.

  9. Nombre de personne travaillant pour chaque société

    Any S, COUNT(X) GROUPBY S WHERE X travaille_pour S
    

    On note qu'il faut définir une variable pour s'en servir pour le groupage. De plus les variables séléctionnée doivent être groupée (mais les variables groupées ne doivent pas forcément être sélectionnées).

Exemples avancés

  1. Toutes les personnes dont le champ nom n'est pas spécifié (i.e NULL)

    Personne P WHERE P nom NULL
    
  2. Toutes les personnes ne travaillant pour aucune société

    Personne P WHERE NOT p travaille_pour S
    
  3. Toutes les sociétés où la personne nommée toto ne travaille pas

    Societe S WHERE NOT P travaille_pour S , P nom 'toto'
    
  4. Toutes les entités ayant été modifiées entre aujourd'hui et hier

    Any X WHERE X modification_date <= TODAY, X modification_date >= TODAY - 1
    
  5. Toutes les notes n'ayant pas de type et à effectuer dans les 7 jours, triées par date

    Any N, D where N is Note, N type NULL, N diem D, N diem >= TODAY,
    N diem < today + 7 ORDERBY D
    
  6. Les personnes ayant un homonyme (sans doublons)

    DISTINCT Personne X,Y where X nom NX, Y nom NX
    

    ou mieux (sans avoir (Xeid, Yeid) et (Yeid, Xeid) dans les résultats)

    Personne X,Y where X nom NX, Y nom NX, X eid XE, Y eid > XE