1.1 Introduction au modèle RDF

Cette section décrit le modèle RDF (Resource Description Framework)

Ressources

Le RDF (Resource Description Framework) est un modèle pour le stockage d'informations sous forme de graphes. Le RDF est employé pour créer des rapports entre différentes ressources, chaque ressource étant une chose, telle qu'une personne, une chanson, une page Web ou un marque-page. Certains considèrent le RDF comme un langage XML de description de données. Cependant, le format RDF/XML est juste une méthode pour stocker du RDF dans un fichier. Si vous essayez d'apprendre le RDF, il peut être déroutant de l'apprendre par l'intermédiaire de la syntaxe RDF/XML ; c'est pourquoi le modèle RDF est décrit ci-dessous, dans assez de détail pour le comprendre sans discuter de la syntaxe RDF/XML.

Imaginez un enchaînement ou un graphique de noeuds interconnectés. Les noeuds sont reliés par l'intermédiaire de diverses relations. Par exemple, disons que chaque noeud représente une personne. Chaque personne pourrait être liée à une autre personne parce qu'elles sont enfants de mêmes parents, parents, conjoints, employés ou des ennemis. Chaque connexion porte le nom de la relation entre les noeuds.

Un autre type de relations est les propriétés physiques d'un noeud. Par exemple, le nom ou l'âge d'une personne. Ces relations seraient nommées par 'nom' et 'âge' au lieu de 'enfant de mêmes parents' ou 'parent'.

le RDF est employé pour décrire ces relations. Il n'inclut pas réellement directement les noeuds, mais indirectement grâce aux relations pointant vers les noeuds. À tout moment, nous pourrions ajouter un nouveau noeud, tel qu'un enfant nouveau-né, et tout ce que nous devons faire est d'ajouter deux liens parents, un pour chaque parent.

Dans le RDF, les noeuds peuvent être de deux types très généraux, ressource ou littéral. Un littéral est une valeur réelle, telle que le nom 'Sandra' ou le nombre '7'. Vous pourriez penser à un littéral comme une chaîne de caractères une fois utilisé dans un langage de programmation. Une ressource se rapprocherait plus d'un objet dans un langage de programmation. Par exemple, une personne serait une ressource, mais le nom de la personne serait un littéral.

Dans le RDF, des ressources sont associées à des URIs permettant de les identifier. Puisqu'un URI est unique, nous pouvons identifier une ressource spécifique. La valeur de l'URI n'est pas vraiment importante dans le RDF puisqu'elle est juste employée comme identifiant. Vous pouvez employer une certaine convention tel qu'un URI qui inclurait un numéro de série permettant d'identifier un objet physique.

Triplets

Nous pouvons ajouter des relations entre deux ressources ou entre une ressource et un littéral. Ces liens s'appellent souvent des triplets ou des arcs. Voici quelques exemples :

<http://www.xulplanet.com/rdf/people/Sandra>  ->  name     ->  Sandra
<http://www.xulplanet.com/rdf/people/Sandra>  ->  gender   ->  femelle
<http://www.xulplanet.com/rdf/people/Sandra>  ->  sibling  ->
      <http://www.xulplanet.com/rdf/people/Kevin>
<http://www.xulplanet.com/rdf/people/Kevin>   ->  gender   ->  male

Par convention dans cette documentation, les items écrits entre les signes supérieurs et inférieurs seront les ressources tandis que les autres seront les littéraux. Quatre triplets sont définis ci-dessus. Le premier indique que la ressource <http://www.xulplanet.com/rdf/people/Sandra> a pour nom Sandra. Le second indique que la même ressource a un genre femelle. Le troisième triplet indique que l'enfant de mêmes parents est une autre ressource <http://www.xulplanet.com/rdf/people/Kevin>. Le triplet final indique un genre pour la ressource <http://www.xulplanet.com/rdf/people/Kevin>.

Aucun nom n'a été fourni pour la ressource <http://www.xulplanet.com/rdf/people/Kevin>. En tant que lecteur humain, nous pourrions supposer que le nom est probablement le littéral 'Kevin ', mais le système informatique n'a aucune manière de le savoir. Nous pourrions employer n'importe quelle forme d'URI pour la ressource ; par exemple ce qui suit serait juste et acceptable :

<urn:x-person:S1>  ->  name  ->   Sandra

La ressource <urn:x-person:S1> ne veut rien dire pour un humain, et serait juste et compréhensible par un système informatique. En fait, un URI moins significatif pour un humain pourrait être meilleur puisque l'arrangement utilisé avec <http://www.xulplanet.com/rdf/people/Sandra> ne fonctionnerait pas si quelqu'un d'autre s'appelait Sandra.

Notez que le fait qu'un URI HTTP soit employé ne signifie pas qu'il soit associé à un site Web par le protocole HTTP, bien qu'il vous soit possible de prévoir un téléchargement à cette adresse. En fait, vous devriez utiliser le nom de votre Web pour créer les URIs afin de garantir leur unicité et éviter à d'autres de les utilisés.

L'URI est juste un identifiant. Le RDF ne s'inquiète pas de ce qu'il est. Mais si le même URI est employé en plusieurs endroits, le RDF comprendra que tous se rapportent à la même ressource. Dans le premier exemple, plusieurs <http://www.xulplanet.com/rdf/people/Sandra> étaient présents, mais ils représentaient tous une même chose.

Le fait de ne pas avoir spécifié de nom pour la ressource <http://www.xulplanet.com/rdf/people/Kevin> ne signifie pas qu'il n'y en a pas. Si le triplet n'est pas spécifié dans le graphe, il ne faut pas considérer que la valeur n'existe pas, mais plutôt que la valeur n'est pas connue ou qu'elle sera fournie plus tard.

Dans l'exemple, vous aurez noté que nous n'avons pas précisé si Kevin est un frère ou une soeur de Sandra. Nous l'avons simplement défini comme 'enfant de mêmes parents'. Toutefois, le système peut le déterminer grâce aux informations fournies et un peu de logique. Par exemple, si le système sait qu'un frère est un enfant male de mêmes parents, il peut déterminer que Kevin est le frère de Sandra en utilisant seulement deux triplets :

<http://www.xulplanet.com/rdf/people/Sandra>  ->  sibling  ->
      <http://www.xulplanet.com/rdf/people/Kevin>
<http://www.xulplanet.com/rdf/people/Kevin>   ->  genre   ->  male

Cependant, ces deux règles ne permettent pas au système de déterminer si Sandra est un frère ou une soeur de Kevin, puisque ces deux règles n'indiquent pas le genre de Sandra. Pour cela, nous aurions besoin de la règle appropriée d'un des exemples précédents.

RDF nous permet de composer des ressources, des littéraux, et même les étiquettes des arcs (tels que 'enfant de mêmes parents'). Ainsi, nous pouvons créer une nouvelle étiquette à tout moment :

<http://www.xulplanet.com/rdf/people/Sandra>  -> bestFriend  ->
      <http://www.xulplanet.com/rdf/people/Christine>

L'étiquette bestFriend, et les autres utilisées ci-dessus s'appellent des prédicats. L'élément à gauche de chaque triplet s'appelle le sujet et celui à droite s'appelle l'objet ou la cible. Le sujet sera toujours une ressource, alors que la cible peut être soit une ressource ou soit un littéral. Vous n'aurez jamais un littéral en relation avec un autre littéral.

Pour assurer l'unicité de l'information, les prédicats sont également identifiés par des URIs. Il y aura un URI unique pour chaque prédicat. Par exemple, l'URI pour 'enfant de mêmes parents' pourrait être <http://www.xulplanet.com/rdf/people/sibling>. Habituellement, les étiquettes de prédicats ayant un rapport entre eux auront des espaces de nommage semblables avec le style XML. Le dernier exemple serait ainsi représenté :

<http://www.xulplanet.com/rdf/people/Sandra>  ->
      <http://www.xulplanet.com/rdf/people/bestFriend>  ->
            <http://www.xulplanet.com/rdf/people/Christine>

Pour les besoins de cette documentation, nous omettrons parfois l'espace de nommage des prédicats pour simplifier les exemples. Les prédicats étant également des ressources, vous pouvez créer des rapports entre un prédicat et autre chose. Cette utilisation sert généralement à définir des propriétés décrivant la signification d'un prédicat, en formant un vocabulaire formel pour ce prédicat.

Vous pouvez avoir de multiples triplets avec le même sujet si vous le souhaitez :

<http://www.xulplanet.com/rdf/people/Sandra>  ->  name  ->  Sandra
<http://www.xulplanet.com/rdf/people/Sandra>  ->  name  ->  Sandy

Ici, la même ressource a un triplet de même prédicat mais avec une cible différente. Dans cet exemple, nous pouvons imaginer que plusieurs noms peuvent signifier l'emploi de surnoms. RDF ne trie pas les noms, donc chacun d'eux a la même pertinence. N'imaginez pas que si Sandra est le premier triplet affiché, il est plus important que Sandy.

Supposons que nous décidons d'ajouter une autre personne également appelée Sandra :

<http://www.xulplanet.com/rdf/people/SandraJr>  ->  name  ->  Sandra

La ressource est différente de celle des exemples précédents car elle représente une personne différente ayant toutefois le même nom. Avec la plupart des APIs RDF, les requêtes peuvent être bi-directionnelles. Si vous ne disposez que du nom Sandra, il vous est possible de lancer une requête inversée pour obtenir toutes les ressources liées à ce nom.

Types

Parfois il est utile de pouvoir identifier le genre d'une ressource, tout comme la façon dont les systèmes orientés objets emploient des classes à cette fin. Le RDF emploie un type à cette fin. En plus des deux types très généraux, ressource et littéral, un type précis peut être attribué à une ressource. Par exemple, la ressource Sandra pourrait avoir un type définissant une personne. La valeur de ce type devrait alors être associée à une autre ressource complétant les informations que le type fournit.

Comme avec d'autres propriétés, les types sont également spécifiés avec un triplet :

<http://www.xulplanet.com/rdf/people/Sandra>  ->  rdf:type  ->
      <http://xmlns.com/wordnet/1.6/Person>

La ressource <http://xmlns.com/wordnet/1.6/Person> est employée pour représenter une personne. L'URI est basé sur WordNet qui fournit des URIs de ressources pour des mots. Le prédicat est rdf:type est dans l'espace de nommage de RDF puisque l'attribut type est intégré à RDF. Le nom complet est http://www.w3.org/1999/02/22-rdf-syntax-ns#type. Ici, nous employons rdf: comme abréviation pour l'espace de nommage du RDF, comme pour un document XML. Il est employé ici comme tel pour simplifier l'exemple -- le prédicat est toujours le nom complet avec l'espace de nommage.

Nous pouvons également composer nos propres types. Dans l'exemple ci-dessous nous associons le type <http://www.xulplanet.com/rdf/example/Poem> comme type d'une ressource dont l'URI laisse deviner qu'il s'agit d'un poème.

<http://www.xulplanet.com/rdf/something/785>  ->  rdf:type  ->
      <http://www.xulplanet.com/rdf/example/Poem>

Quelques types de liste

RDF dispose d'un certain nombre de types intégrés pour représenter des listes de choses. Reprenons un exemple précédent où Sandra avait deux noms. Il était mentionné que les noms n'avaient pas d'ordre particulier. Parfois, il peut être utile de pouvoir mettre un ensemble de valeurs dans un ordre particulier. Vous pourriez réfléchir aux manières pour contourner ceci, par exemple en utilisant des attributs 'name1', 'name2' et ainsi de suite. RDF a un mécanisme intégré pour faire ce genre de chose.

En RDF, un prédicat constitué d'un nombre précédé par un underscore est employé comme un item d'une liste. Par exemple, rdf:_1 est employé pour indiquer le premier item d'une liste. Nous employons encore l'espace de nommage du RDF. Par exemple, nous pourrions créer une liste de choses comme ceci :

<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:_1  ->
      <http://www.xulplanet.com/rdf/people/Sandra>
<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:_2  ->
      <http://www.xulplanet.com/rdf/people/Kevin>
<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:_3  ->
      <http://www.xulplanet.com/rdf/people/Jack>

Ici, <http://www.xulplanet.com/rdf/people/Karen> est une liste de trois items. Nous, en tant qu'humains, pourrions présumer que les trois items sont les enfants de Karen à la différence du système informatique, mais votre application pourrait faire cette hypothèse. Les trois prédicats ne sont en aucun cas spécifiques, car nous pourrions employer 'name1', 'name2' et 'name3'. Cependant, puisque le RDF permet les prédicats ci-dessus intégrés, nous devrions les employer autant que possible.

Puisque rdf:_XXX représente juste des prédicats, comme n'importe quels autres, nous pourrions indiquer des valeurs multiples avec le même nombre, ou nous pourrions omettre certaines valeurs :

<http://w>w.xulplanet.com/rdf/people/Karen>  ->  rdf:_1  ->
      <http://www.xulplanet.com/rdf/people/Sandra>
<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:_6  ->
      <http://www.xulplanet.com/rdf/people/Kevin>
<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:_6  ->
      <http://www.xulplanet.com/rdf/people/Billy>
<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:_8  ->
      <http://www.xulplanet.com/rdf/people/Jack>

Ce qui précède est une liste contenant quatre items. Cependant, les nombres ne sont pas séquentiels. La création de tels triplets n'est pas fréquent, mais une liste contenant des omissions de nombres se rencontre lorsque des items ont été effacés.

Afin que le RDF puisse traiter ces prédicats numérotés d'une manière spéciale -- rappelez-vous que ce sont juste des prédicats ordinaires -- le RDF exige également d'employer un type spécial pour les listes. Plusieurs types de liste sont disponibles :

rdf:Seq :

une liste ordonnée, qui est ce que nous voulons utiliser pour les exemples précédents.

rdf:Bag :

une liste non ordonnée.

rdf:Alt :

une liste de valeurs alternatives où seule une valeur sera utilisée.

Pour les exemples ci-dessus, nous emploierons rdf:Seq pour que les items soient placés dans un ordre spécifique. Nous emploierions rdf:Bag si l'ordre des items n'importait pas. Il n'y aurait aucune différence avec l'emploi de plusieurs prédicats 'nom' identiques, toutefois si le type est rdf:bag, nous saurions que la ressource contient une liste de noms au lieu d'un seul. Pour des noms, nous pourrions employer un type rdf:Alt lorsqu'une application devra utiliser un seul des noms à la fois.

Nous assignons ces types de liste simplement comme n'importe quel autre type décrit ci-avant :

<http://www.xulplanet.com/rdf/people/Karen>  ->  rdf:type  ->
      <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq>

Ici, l'espace de nommage 'rdf' est utilisé pour la valeur à atteindre. Maintenant que Karen est du type rdf:Seq, nous pouvons ajouter les trois enfants comme ci-dessus. Le problème ici est que maintenant que Karen est du type rdf:Seq, elle n'est plus du type personne Person. Nous pourrions résoudre ce problème en assignant un deuxième type à Karen, comme avec d'autres prédicats. Une meilleure manière est d'employer une deuxième ressource comme conteneur de la liste des enfants de Karen. Karen restera une personne, mais la liste d'enfants sera du type rdf:Seq.

<http://www.xulplanet.com/rdf/people/Karen>       ->  rdf:type  ->
      <http://xmlns.com/wordnet/1.6/Person>
<http://www.xulplanet.com/rdf/people/Karen>       ->  children  ->
      <http://www.xulplanet.com/rdf/people/KarensKids>
<http://www.xulplanet.com/rdf/people/KarensKids>  ->  rdf:type  ->
      <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq>
<http://www.xulplanet.com/rdf/people/KarensKids>  ->  rdf:_1    ->
      <http://www.xulplanet.com/rdf/people/Sandra>
<http://www.xulplanet.com/rdf/people/KarensKids>  ->  rdf:_2    ->
      <http://www.xulplanet.com/rdf/people/Kevin>
<http://www.xulplanet.com/rdf/people/KarensKids>  ->  rdf:_3    ->
      <http://www.xulplanet.com/rdf/people/Jack>

Nous avons fait de Karen une personne, et lui avons assigné un lien avec une ressource <http://www.xulplanet.com/rdf/people/KarensKids> par l'intermédiaire du prédicat enfants children. Au lieu d'associer les trois enfants directement à Karen, nous les associons à cette ressource supplémentaire qui a un type rdf:Seq. Le résultat est que Karen est associée aux trois enfants mais en conservant un type unique de personne.

En termes de RDF, nous n'avons pas besoin d'indiquer explicitement l'URI <http://www.xulplanet.com/rdf/people/KarensKids>. Puisque le modèle ci-dessus est généralement employé, RDF permet d'utilisation des noeuds vides ou des ressources anonymes. Une API RDF vous permettra de créer ces noeuds, et habituellement un URI pourrait être aléatoirement produit pour vous. Techniquement, ils n'ont pas d'URIs, mais vous pouvez toujours les manipuler comme des ressources, et ajoutez ou enlevez des triplets qui leurs sont liés

Dans tous les exemples ci-dessus, nous avons toujours défini des triplets. Chaque ligne a un sujet, un prédicat et un objet. Même lorsque nous définissons des types et des listes, nous employons toujours des triplets pour les définir. Le RDF est seulement une liste de triplets, ou de liens entre les choses.

Une chose intéressante au sujet de RDF est que nous pourrions prendre une liste de triplets d'une source et les combiner avec des triplets d'une autre source. Puisque l'ordre est sans importance, nous aurions le même résultat que si nous avions commencé par les définir ensemble. Par exemple, supposons qu'une autre source fournisse le triplet suivant :

<http://www.xulplanet.com/rdf/people/KarensKids>  ->  rdf:_4  ->
      <http://www.xulplanet.com/rdf/people/Wendy>

Une fois combiné avec l'exemple précédent, il signifierait que Karen aurait maintenant quatre enfants au lieu de trois. C'est un aspect important du RDF -- pouvoir combiner ou agréger des données de sources multiples.

Exemple de triplets

Dans le contexte d'un navigateur, les marque-pages peuvent être stockés comme une série de triplets RDF.

  <urn:x-mark:1>  ->  Name         ->  XULPlanet.com
  <urn:x-mark:1>  ->  URL          ->  <http://www.xulplanet.com>
  <urn:x-mark:1>  ->  LastVisited  ->  Sept 8, 2003
  <urn:x-mark:2>  ->  Name         ->  mozilla.org
  <urn:x-mark:2>  ->  URL          ->  <http://www.mozilla.org>

Cet exemple contient cinq triplets décrivant deux marque-pages. Chaque marque-page a un nom Name et une URL, et l'un d'eux a un prédicat LastVisited. Les valeurs de l'URL sont placées dans une autre ressource, ce qui signifie qu'elles pourraient être employées dans d'autres triplets.

Si vous avez différents types de marque-pages, vous pourriez créer un type pour chacun d'eux. Par exemple, votre application pourrait avoir un concept d'abonnement stocké comme un marque-page, ainsi vous pourriez employer un type pour celui-ci :

  <urn:x-mark:1>  ->  rdf:type  -> http://www.xulplanet.com/rdf/example/Subscription

Vous pourriez utiliser la convention disant qu'un marque-page de type Seq est un dossier de marque-pages. Les enfants de ce Seq seraient les marque-pages stockés dans le dossier.

  <urn:x-mark:folder>  ->  rdf:type  <http://www.w3.org/1999/02/22-rdf-syntax-ns#Seq>
  <urn:x-mark:folder>  ->  rdf:_1    <urn:x-mark:1>
  <urn:x-mark:folder>  ->  rdf:_2    <urn:x-mark:2>

Il s'agissait seulement d'un exemple des genres de choses pouvant être stockés avec RDF. Presque toute sorte de données peuvent être gérée avec RDF.