Le langage d'association D2RQ

Ce document décrit le langage d'association D2RQ, un langage déclaratif pour l'association des schémas d'une base de données relationnelle aux vocabulaires RDF et ontologies OWL. Le langage est implémenté dans la plate-forme D2RQ. Commentez Donner une note à l'article (5)

Article lu   fois.

Les trois auteur et traducteurs

Profil ProSite personnel

Traducteur : Profil Pro

Traducteur : Profil Pro

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction

Le langage d'association D2RQ est un langage déclaratif permettant de décrire la relation entre le schéma d'une base de données relationnelle et des vocabulaires RDFS ou des ontologies OWL.

Une association D2RQ est elle-même un document RDF utilisant la syntaxe Turtle. Les associations sont exprimées en utilisant des termes de l'espace de noms D2RQ :

 
Sélectionnez
http://www.wiwiss.fu-berlin.de/suhl/bizer/D2RQ/0.1#

Les termes de cet espace de noms sont formellement définis dans le schéma RDF D2RQ (version Turtle, version RDF/XML).

L'association définit un graphe RDF virtuel qui contient des informations provenant de la base de données. Ceci est similaire à la notion de vues en SQL, excepté que la structure de données virtuelle est un graphe RDF et non une table relationnelle virtuelle. Le graphe RDF virtuel peut être accédé de différentes manières, dépendant de ce qui est offert par l'implémentation. La plate forme D2RQ fournit un accès SPARQL, un serveur de données liées, un générateur de sauvegardes RDF, une simple interface HTML, et un accès à l'API Jena pour la base de données associée via D2RQ.

Les associations D2RQ peuvent être écrites à la main dans un éditeur de texte, mais habituellement il est plus rapide de démarrer avec l'outil generate-mapping qui génère un squelette « d'association par défaut » à partir du schéma de la base de données.

La figure ci-dessous montre la structure d'un exemple d'association D2RQ :

Image non disponible

La base de données est associée aux termes RDF, exposés sur la droite, en utilisant des d2rq:ClassMap et des d2rq:PropertyBridge. Les objets les plus importants dans l'association sont les associations de classe. Une association de classes représente une classe ou un groupe de classes similaires d'une ontologie. Une association de classe spécifie comment les URI (ou les nœuds anonymes) sont générées pour les instances de la classe. Elle a un ensemble de propriétés-ponts, qui spécifient comment les propriétés des instances sont créées.

II. Exemple d'association D2RQ

Exemple ISWC : tout au long de ce manuel, nous utiliserons une base de données exemple qui stocke des informations à propos de conférences, de publications, d'auteurs et de sujets. Cette base de données est associée à l'ontologie de la communauté internationale du Web sémantique (ISWC).

  • Fichier d'associations D2RQ de l'ISWC : mapping-iswc.ttl.
  • Base de données exemple (avec quelques entrées provenant de la conférence ISWC 2002) : iswc-mysql.sql (sauvegarde MySQL).
  • Ontologie ISWC : iswc.daml.

Exemple WordPress : un autre exemple associe le schéma d'une base de données WordPress en RDF :

Modèle : l'exemple suivant d'association D2RQ concerne la table des conférences dans la base de données associée à la classe conférence dans une ontologie. Vous pouvez utiliser cette association comme un modèle pour écrire vos propres associations.

 
Sélectionnez
# Espace de noms D2RQ  
@prefix d2rq:        <http://www.wiwiss.fu-berlin.de/suhl/bizer/D2RQ/0.1#> .
# Espace de noms de l'ontologie
@prefix : <http://annotation.semanticweb.org/iswc/iswc.daml#> .

# Espace de noms du fichier d'associations ; n'apparaît pas dans les données associées
@prefix map: <file:///Users/d2r/example.ttl#> .

# Autres espaces de noms
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> . 

map:Database1 a d2rq:Database;
    d2rq:jdbcDSN "jdbc:mysql://localhost/iswc";
    d2rq:jdbcDriver "com.mysql.jdbc.Driver";
    d2rq:username "utilisateur";
    d2rq:password "mot de passe";
    .
# -----------------------------------------------
# CREATE TABLE Conferences (ConfID int, Name text, Location text);

map:Conference a d2rq:ClassMap;
    d2rq:dataStorage map:Database1;
    d2rq:class :Conference;
    d2rq:uriPattern "http://conferences.org/comp/confno@@Conferences.ConfID@@";
    .
map:eventTitle a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Conference;
    d2rq:property :eventTitle;
    d2rq:column "Conferences.Name";
    d2rq:datatype xsd:string;
    .
map:location a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Conference;
    d2rq:property :location;
    d2rq:column "Conferences.Location"; 
    d2rq:datatype xsd:string;
    .

Les constructions individuelles du langage d'association D2RQ sont décrites en détail ci-dessous.

III. Connexion à une base de données (d2rq:Database)

Un d2rq:Database définit une connexion JDBC à une base de données relationnelle locale ou distante. Une association D2RQ peut contenir plusieurs d2rq:Database pour accéder à différentes bases de données.

III-A. Propriétés de d2rq:Database

d2rq:jdbcDSN

L'URL JDBC de la base de données. C'est une chaîne de caractères de la forme jdbc:subrprotocol:subname. Pour une base de données MySQL, cette chaîne de caractères ressemble à jdbc:mysql://hostname:port/dbname. Exemples pour d'autres bases de données.

d2rq:jdbcDriver

Nom de la classe du pilote JDBC pour la base de données. Utilisé de concert avec d2rq:jdbcDSN. Exemple : com.mysql.jdbc.Driver pour MySQL.

d2rq:username

Un nom d'utilisateur s'il est requis par la base de données.

d2rq:password

Mot de passe s'il est requis par la base de données.

 d2rq:resultSizeLimit

Une valeur entière qui sera ajoutée comme une clause LIMITE pour toutes les requêtes SQL générées. Ceci fixe une limite maximum pour le nombre de résultats retournés par des bases de données volumineuses. Notez que cette efficacité peut « paralyser » le serveur et peut causer des résultats imprévisibles. Regardez aussi d2rq:limit. et d2rq:limitInverse qui peuvent être utilisés pour imposer des limites de résultats sur une propriété-pont individuelle.

d2rq:fetchSize

Une valeur entière qui spécifie le nombre de lignes à récupérer avec chaque requête sur la base de données. Cette valeur est particulièrement importante pour contrôler les ressources mémoire de D2RQ et du serveur de base de données lorsqu'une sauvegarde est réalisée. dump-rdf fixe cette valeur à 500 par défaut, ou à Integer.MIN_VALUE pour MySQL afin d'activer le mode streaming.

d2rq:startupSQLScript

URL d'un script SQL à exécuter au démarrage. Utile pour initialiser la connexion et la tester. Pour charger à partir du système de fichiers relativement à l'emplacement du fichier d'associations, utilisez cette syntaxe : d2rq:startupSQLScript <file:script.sql>;

d2rq:textColumn d2rq:numericColumn d2rq:dateColumn d2rq:timestampColumn d2rq:timeColumn d2rq:binaryColumn d2rq:booleanColumn d2rq:bitColumn d2rq:intervalColumn

Ces propriétés sont utilisées pour déclarer le type de colonne des colonnes de la base de données. Cela affecte le type de littéral SQL que D2RQ utilisera pour requêter les valeurs dans cette colonne. Les objets de ces propriétés sont des noms de colonnes dans la notation Nom_table.nom_colonne. Ces propriétés n'ont pas besoin d'être spécifiées à moins que le moteur soit pour quelque raison incapable de déterminer le type correct de la colonne par lui-même. Le d2rq:timestampColumn est pour les types de colonnes qui combinent une date et un temps. Le d2rq:binaryColumn est pour les types de colonnes qui contiennent des données binaires comme des BLOB.

III-B. Exemple : connexion à une base de données MYSQL

 
Sélectionnez
map:Database1 a d2rq:Database;
    d2rq:jdbcDSN "jdbc:mysql://localhost/iswc";
    d2rq:jdbcDriver "com.mysql.jdbc.Driver";
    d2rq:username "utilisateur";
    d2rq:password "mot de passe";
    .

III-C. Spécifier les propriétés de connexion JDBC

La plupart des pilotes JDBC proposent une gamme de propriétés de connexions JDBC, qui spécifient des options de configuration avancées pour la connexion JDBC à la base de données. Un fichier d'associations D2RQ peut être construit pour utiliser des propriétés de connexion arbitraires lors de la création de la connexion JDBC. Cela est fait par l'intermédiaire de l'espace de noms jdbc: (URI de l'espace de noms : http://d2rq.org/terms/jdbc/). Les propriétés RDF dans cet espace de noms seront passées comme propriétés de connexion. Consultez la documentation de votre pilote JDBC pour une liste des propriétés disponibles.

 
Sélectionnez
@prefix jdbc: <http://d2rq.org/terms/jdbc/> .

map:database a d2rq:Database;
    # ... configuration d'une autre base de données ...
    jdbc:autoReconnect "true";
    jdbc:zeroDateTimeBehavior "convertToNull";
    .

L'exemple utilise deux propriétés de connexion qui sont comprises par le pilote JDBC de MySQL : autoReconnect=true et zeroDateTimeBehavior=convertToNull.

III-D. Garder en fonctionnement des connexions sur le long terme

Certains serveurs de bases de données, comme MySQL, peuvent mettre fin à des connexions clientes ouvertes après un certain intervalle (par défaut, pour MySQL c'est huit heures). Pour garder en fonctionnement des connexions sur le long terme, D2RQ peut être configuré pour exécuter périodiquement des requêtes « noop ». Cette fonctionnalité peut être activée avec une propriété spéciale jdbc:keepAlive. Un exemple est donné ci-dessous :

 
Sélectionnez
@prefix jdbc: <http://d2rq.org/terms/jdbc/> .

map:database a d2rq:Database;
    # ... configuration d'une autre base de données ...
    jdbc:keepAlive "3600"; # valeur en secondes
    jdbc:keepAliveQuery "SELECT 1"; # (optionnel pour remplacer la requête noop par défaut)
    .

Par défaut, la requête « noop » est « SELECT 1 », qui peut ne pas fonctionner avec certains DBMS (système de gestion de bases de données). Pour cette raison, la requête par défaut peut être remplacée avec une requête « noop » personnalisée.

IV. Configuration globale du moteur d'association (d2rq:Configuration)

Un d2rq:Configuration contrôle le comportement global de D2RQ. Il est généralement non requis si les paramètres par défaut sont satisfaisants.

IV-A. Propriétés de d2rq:Configuration

d2rq:serveVocabulary

Pour alimenter les données d'un vocabulaire inférées et fournies par l'utilisateur (booléen ; true par défaut). Cette option est automatiquement définie quand on utilise l'option de la ligne de commande --fast de D2RQ.

d2rq:useAllOptimizations

Utiliser les optimisations de saignement d'arêtes (booléen ; false par défaut).

IV-B. Exemple : activation des optimisations

Dans le but d'activer les optimisations du saignement d'arête, un bloc d2rq:Configuration avec la propriété d2rq:useAllOptimizations fixée à true est créé.

 
Sélectionnez
map:Configuration a d2rq:Configuration;
    d2rq:useAllOptimizations true.

V. Créer des ressources RDF (d2rq:ClassMap)

Un d2rq:ClassMap représente une classe ou un groupe de classes similaires d'une ontologie OWL ou d'un schéma RDFS. Une association de classe définit comment les instances de la classe sont identifiées. Elle est connectée à un d2rq:Database et à un ensemble de d2rq:PropertyBridges qui attribuent des propriétés aux instances.

V-A. Ressource d'identité

D2RQ fournit quatre mécanismes différents pour assigner les identifiants aux instances dans la base de données :

Modèles d'URI

Un modèle d'URI est instancié par des valeurs insérées de certaines colonnes de la base de données dans un modèle. Exemples :

 
Sélectionnez
http://example.org/persons/@@Persons.ID@@
http://example.org/lineItems/item@@Orders.orderID@@-@@LineItems.itemID@@
urn:isbn:@@Books.isbn@@
mailto:@@Persons.email@@

Les parties entre les @@ marquent les colonnes de la base de données dans la notation Table.Colonne. Les modèles d'URI sont utilisés avec la propriété d2rq:uriPattern.

Certains caractères, comme les espaces ou le signe #, ne sont pas permis dans les URI ou ont un sens spécial. Les colonnes qui contiennent ces caractères doivent être encodées avant leurs valeurs qui peuvent être insérées dans un modèle d'URI :

  • si une colonne est donnée comme @@Table.Colonne | urlencode@@, alors l'encodage d'URL est appliqué avant que la chaîne soit insérée ;
  • si une colonne est donnée comme @@Table.Colonne | urlify@@, alors l'encodage d'URL est utilisé, avec une règle additionnelle qui convertit les espaces en souligné (_). Quelques personnes trouvent que ceci produit des URI plus conviviales ;
  • si une colonne est donnée comme @@Table.Colonne | encode@@, alors l'encodage pour cent (comme défini dans Direct Mapping du W3C) est appliqué avant que la chaîne soit insérée.

Si des URI produites par un modèle d'URI avec un encodage donné sont aussi produites ailleurs dans l'association D2RQ sans utiliser ce même encodage (par exemple, à partir d'une d2rq:uriColumn ou d'une d2rq:constantValue) alors les requêtes SPARQL qui « joignent » ces URI peuvent ne pas fonctionner comme attendu.

Les modèles d'URI relatives

Un modèle d'URI relative est un modèle d'URI qui génère des URI relatives :

 
Sélectionnez
persons/@@Persons.ID@@

Les personnes seront combinées avec une URI de base fournie par l'environnement de traitement pour former des URI pleines. Les modèles d'URI relatives permettent la création d'associations portables qui peuvent être utilisées pour de multiples instances du même schéma de base de données. Les modèles d'URI relatives sont générés avec la propriété d2rq:uriPattern.

Les colonnes URI

Dans certains cas, la base de données peut déjà contenir les URI qui peuvent être utilisées comme identifiants de ressources, comme une page Web et les URL d'un document. Les URI sont générées à partir des colonnes avec la propriété d2rq:uriColumn.

Les expressions URI

Les URI peuvent être générées avec une expression SQL, spécifiée via d2rq:uriSqlExpression. L'expression doit produire une URI valide.

Les nœuds anonymes

RDF a aussi un concept de nœuds anonymes, qualificatifs existentiels qui signifient que quelques ressources existent et ont certaines propriétés, mais sans être nommées. Dans D2RQ, les nœuds anonymes peuvent être générés à partir d'une ou plusieurs colonnes. Un nœud anonyme distinct sera généré pour chaque ensemble de valeurs distinct de ces colonnes. Les colonnes sont spécifiées en utilisant la propriété d2rq:bNodeIdColumns.

Notez que les nœuds anonymes ne peuvent pas être référencés à partir de l'extérieur du graphe RDF où ils existent dans D2RQ. Cela limite leur utilité, et ils sont donc à éviter.

Association de classe singleton

Un d2rq:ClassMap produit généralement beaucoup de ressources. Quelquefois, il est préférable d'avoir une association de classe qui produit une ressource unique avec une identité statique fixée. Dans ce cas, on peut utiliser la propriété d2rq:constantValue pour fournir l'URI pour cette instance.

V-B. Propriétés de d2rq:ClassMap

d2rq:dataStorage

Se réfère à un d2rq:Database où l'instance des données est stockée.

d2rq:class

Une classe RDF-S ou OWL. Toutes les ressources générées par cette association de classe sont des instances de cette classe.

d2rq:uriPattern

Spécifie un modèle d'URI qui sera utilisé pour identifier les instances de cette association de classe.

 d2rq:uriColumn

Une colonne de base de données contenant des références d'URI pour identifier les instances de cette association de classe. Le nom de la colonne doit être de la forme « NomTable.NomColonne ».

d2rq:uriSqlExpression

Une expression SQL qui génère des identifiants pour les instances de cette association de classe. Similaire à d2rq:sqlExpression. La sortie doit être une URI valide. Notez que requêter pour une telle valeur calculée pourrait imposer une lourde charge à la base de données. Voir l'exemple ci-dessous.

d2rq:bNodeIdColumns

Une liste de noms de colonnes séparés par une virgule avec la notation « NomTable.NomColonne ». Les instances de cette association de classe seront des nœuds anonymes : un nœud anonyme distinct par tuple distinct de ces colonnes.

 d2rq:constantValue

Cette association de classe aura une seule instance, nommée par la valeur de cette propriété. Ceci peut être un nœud anonyme ou une URI.

d2rq:containsDuplicates

Doit être spécifié si une association de classe utilise des informations provenant de tables qui ne sont pas complètement normalisées. Si la valeur de la propriété d2rq:containsDuplicates est fixée à « true », alors D2RQ ajoute une clause DISTINCT à toutes les requêtes utilisant cette association de classe. « False » est la valeur par défaut, qui ne doit pas être explicitement déclarée. Ajouter cette propriété à une association de classe basée sur les tables de la base de données normalisée dégrade la performance des requêtes, mais n'affecte pas les résultats de la requête.

d2rq:additionalProperty

Ajoute une AdditionnalProperty à toutes les instances de cette classe. Ceci peut être utile pour ajouter des propriétés rdfs:seeAlso ou d'autres déclarations fixées à toutes les instances de la classe.

d2rq:condition

Spécifie une condition SQL WHERE. Une instance de cette classe sera seulement générée pour les lignes de la base de données qui satisfont la condition. Les conditions peuvent être utilisées pour cacher les parties de la base de données venant de D2RQ, par exemple empêcher l'accès aux données qui sont antérieures ou postérieures à une certaine date. Voir la section Association conditionnelle pour les détails.

d2rq:classDefinitionLabel

Spécifie un label qui sera servi comme rdfs:label pour toutes les définitions de la classe associée. Les labels multiples, par exemple plusieurs langues, sont pris en charge.

d2rq:classDefinitionComment

Spécifie un commentaire qui sera utilisé comme rdfs:comment pour toutes les définitions de la classe associée. Les commentaires multiples sont supportés.

d2rq:additionalClassDefinitionProperty

Ajoute une AdditionnalProperty à toutes les définitions de classes associées.


Par ailleurs, d2rq:valueMaxLength, d2rq:valueRegex, d2rq:valueContains et d2rq:translateWith peuvent être utilisés et fonctionnent de la même façon que sur les propriétés-ponts.

d2rq:join et d2rq:alias peuvent aussi être utilisés et sont hérités par l'association des propriétés-ponts.

V-C. Exemple : identifier les instances d'association de classes avec un modèle d'URI

 
Sélectionnez
map:PaperClassMap a d2rq:ClassMap;
    d2rq:uriPattern "http://www.conference.org/conf02004/paper#Paper@@Papers.PaperID@@";
    d2rq:class :Paper;
    d2rq:classDefinitionLabel "publication"@fr;
    d2rq:classDefinitionComment "Une publication de conférence."@fr;
    d2rq:dataStorage map:Database1;
    .

La propriété d2rq:class est utilisée pour indiquer que toutes les ressources générées par le d2rq:ClassMap sont des instances d'une classe RDFS ou OWL. D2RQ crée automatiquement les triplets rdf:type nécessaires.

V-D. Exemple : instances d'association de classe avec des nœuds anonymes

 
Sélectionnez
map:Topic a d2rq:ClassMap;
    d2rq:bNodeIdColumns "Topics.TopicID";
    d2rq:class :Topic;
    d2rq:classDefinitionLabel "sujet"@fr;
    d2rq:classDefinitionComment "Un sujet."@fr;
    d2rq:dataStorage map:Database1;
    .

V-E. Exemple : un groupe de classes toutes associées à partir de la même table

Si vous voulez utiliser une association de classe pour un groupe de classes avec les mêmes propriétés (comme Personne, Professeur, Chercheur, Étudiant) qui viennent tous de la même table, vous devez créer une déclaration rdf:type avec une propriété-pont objet à la place de l'utilisation de d2rq:class.

 
Sélectionnez
map:PersonsClassMap a d2rq:ClassMap;
    d2rq:uriColumn "Persons.URI";
    d2rq:dataStorage map:Database1;
    .
map:PersonsType a d2rq:PropertyBridge;
    d2rq:property rdf:type;
    d2rq:pattern "http://annotation.semanticweb.org/iswc/iswc.daml#@@Persons.Type@@"; 
    d2rq:belongsToClassMap map:PersonsClassMap
    .

Ici, la classe de chaque personne est obtenue en préfixant les valeurs de la colonne Persons.Type avec l'espace de noms d'une ontologie. Si les noms de classe dans l'ontologie ne peuvent pas être construits directement à partir des valeurs de Persons.Type, alors une TranslationTable pourrait être utilisée pour l'alignement des noms de classe et des valeurs de la base de données.

VI. Ajouter des propriétés aux ressources (d2rq:PropertyBridge)

Une d2rq:PropertyBridge met en relation la colonne d'une base de données et une propriété RDF. Les propriétés-ponts sont utilisées pour attacher les propriétés aux ressources RDF créées par une association de classe. Les valeurs de ces propriétés sont souvent des littéraux, mais peuvent aussi être des URI ou des nœuds anonymes qui mettent en relation la ressource et les autres ressources, par exemple la valeur de la propriété :author d'une publication pourrait être une URI représentant une personne.

Si l'une des colonnes utilisées dans une propriété-pont est NULL pour quelques lignes de la base de données, alors aucune propriété n'est créée pour les ressources correspondant à ces lignes.

VI-A. Propriétés de d2rq:PropertyBridge

d2rq:belongsToClassMap

Spécifie que la propriété-pont appartient à un d2rq:ClassMap. Doit être spécifié pour toutes les propriétés-ponts.

d2rq:property

La propriété qui connecte l'association de classe avec l'objet ou le littéral créé par le pont. Doit être spécifiée pour toutes les propriétés-ponts. Si plusieurs, d2rq:properties sont spécifiés, alors un triplet avec chaque propriété est généré par ressource.

d2rq:dynamicProperty

Un modèle d'URI qui est utilisé pour générer l'URI de la propriété à l'exécution. Si plusieurs d2rq:dynamicProperty sont spécifiés, alors un triplet avec chaque propriété est généré par ressource.

d2rq:column

Pour les propriétés avec des valeurs littérales. La colonne de la base de données qui contient des valeurs littérales. Les noms de colonne doivent être donnés dans la forme « NomTable.NomColonne ».

 d2rq:pattern

Pour les propriétés avec des valeurs littérales. Peut être utilisé pour étendre et combiner les valeurs de la colonne avant qu'elles soient utilisées comme une valeur littérale de la propriété. Si un modèle contient plus qu'une colonne, alors une chaîne séparatrice, qui ne peut pas apparaître dans les valeurs de la colonne, doit être utilisée entre les noms de colonne afin de permettre à D2RQ de renverser les littéraux donnés dans les valeurs de colonne.

d2rq:sqlExpression

Pour les propriétés avec des valeurs littérales. Génère des valeurs littérales en évaluant une expression SQL. Notez que requêter une telle valeur calculée pourrait mettre la base de données en lourde charge. Voir l'exemple ci-dessous.

d2rq:datatype

Pour les propriétés avec des valeurs littérales. Spécifie le type de donnée RDF des littéraux.

d2rq:lang

Pour les propriétés avec des valeurs littérales. Spécifie l'étiquette langage des littéraux.

d2rq:constantValue

Pour les propriétés qui ont la même valeur constante sur toutes les instances de l'association de classe. La valeur peut être un littéral, un nœud anonyme, ou une URI. Voir l'exemple ci-dessous.

d2rq:refersToClassMap

Pour les propriétés qui correspondent à une clé étrangère. Référence un autre d2rq:ClassMap qui crée les instances qui sont utilisées comme les valeurs de ce pont. Si ces instances viennent d'une autre table, alors une ou plusieurs propriétés d2rq:join doivent être spécifiées pour sélectionner les instances correctes. Voir l'exemple ci-dessous.

d2rq:uriColumn d2rq:uriPattern d2rq:uriSqlExpression

Pour les propriétés où la valeur est supposée être une URI à la place d'un littéral. Elles fonctionnent de la même façon que sur les associations de classe.

 d2rq:join

Si les colonnes utilisées pour créer une valeur littérale ou objet ne proviennent pas des mêmes tables (ou de la même table) de la base de données contenant les colonnes d'association de classe, alors les tables doivent être jointes ensemble en utilisant une ou plusieurs propriétés d2rq:join. Voir l'exemple ci-dessous.

 d2rq:alias

Les alias prennent la forme « Table AS Alias » et sont utilisés quand une table a besoin d'être jointe à elle-même. La table peut être référencée pour utiliser l'alias dans la propriété-pont. Voir l'exemple ci-dessous.

d2rq:condition

Spécifie une condition SQL WHERE. Le pont générera seulement un statut si la condition y est. Un usage commun est de supprimer les triplets avec des valeurs de littéraux vides : d2rq:condition "Table.Colonne <> ''" Voir section associations conditionnelles pour les détails.

 d2rq:translateWith

Assigne un d2rq:TranslationTable à la propriété-pont. Les valeurs de d2rq:column ou d2rq:pattern seront traduites par la table. Voir la section TranslationTable pour les détails.

 d2rq:valueMaxLength

Affirme que toutes les valeurs de ce pont ne sont pas plus longues qu'un nombre de caractères donné. Ceci permet à D2RQ d'accélérer les requêtes. Voir la section optimisation de la performance pour les détails.

 d2rq:valueContains

Affirme que toutes les valeurs de ce pont contiennent toujours une chaîne donnée. Ceci permet à D2RQ d'accélérer les requêtes. Plus utile en conjonction avec d2rq:column. Voir la section optimisation de la performance pour les détails.

 d2rq:valueRegex

Affirme que toutes les valeurs de ce pont correspondent à une expression régulière donnée. Ceci permet à D2RQ d'accélérer les requêtes. Plus utile en conjonction avec d2rq:column sur les colonnes dont les valeurs sont très différentes des autres colonnes dans la base de données. Voir la section optimisation de la performance pour les détails.

d2rq:propertyDefinitionLabel

Spécifie un label qui sera servi comme rdfs:label pour toutes les définitions de propriétés associées. Les labels multiples, par exemple plusieurs langues, sont pris en charge.

d2rq:propertyDefinitionComment

Spécifie un commentaire qui sera servi comme rdfs:comment pour toutes les définitions de la propriété associée. Plusieurs commentaires sont supportés.

d2rq:additionalPropertyDefinitionProperty

Ajouter une AdditionnalProperty à toutes les définitions de propriétés associées.

 d2rq:limit

Le nombre maximum de résultats à récupérer dans la base de données pour cette propriété-pont. Voir aussi d2rq:resultSizeLimit.

 d2rq:limitInverse

Le nombre maximum de résultats à récupérer pour les statuts inverses de cette propriété-pont.

d2rq:orderAsc

La colonne d'après laquelle trier les résultats en ordre croissant pour cette propriété-pont. Utile quand les résultats sont limités en utilisant d2rq:limit.

d2rq:orderDesc

La colonne d'après laquelle trier les résultats en ordre décroissant pour cette propriété-pont. Utile quand les résultats sont limités en utilisant d2rq:limit.

VI-B. Exemple : une simple propriété-pont

 
Sélectionnez
map:PaperTitle a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:property :title;
    d2rq:column "Papers.Title";
    d2rq:lang "fr";
    d2rq:propertyDefinitionLabel "titre"@fr;
    d2rq:propertyDefinitionComment "Un titre de publication."@fr;
    .

Ceci attache une propriété :title à toutes les ressources générées par l'association de classe map:Paper. Les valeurs de la propriété sont prises dans la colonne Papers.Title. Les littéraux générés auront une étiquette langue « fr ».

VI-C. Exemple : propriété-pont utilisant des informations d'une autre table

 
Sélectionnez
map:authorName a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Papers;
    d2rq:property :authorName;
    d2rq:column "Persons.Name";
    d2rq:join "Papers.PaperID <= Rel_Person_Paper.PaperID";
    d2rq:join "Rel_Person_Paper.PersonID => Persons.PerID";
    d2rq:datatype xsd:string;
    d2rq:propertyDefinitionLabel "nom"@fr;
    d2rq:propertyDefinitionComment "nom d'un auteur."@fr;
    .

Plusieurs propriétés :authorName seront ajoutées. Les tables Papers et Persons sont dans une relation n:m. d2rq:join est utilisé pour joindre les tables sur Rel_Person_Paper. La condition de jointure contient des flèches directes qui indiquent la relation de la clé étrangère et sont utilisées dans une trace d'optimisation. Dans l'exemple ci-dessus, les directions des flèches indiquent que toutes les valeurs possibles de Rel_Person_Paper.PaperID et Rel_Person_Paper.PersonID sont présentes dans Papers.PaperID et Persons.PerID, respectivement. Quand ceci n'est pas clair, un simple signe d'équation (=) peut être utilisé.

VI-D. Exemple : une propriété-pont avec des URI mailto:

 
Sélectionnez
map:PersonsClassEmail a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:PersonsClassMap;
    d2rq:property :email;
    d2rq:uriPattern "mailto:@@Persons.Email@@";
    .

Le modèle mailto:@@Persons.Email@@ est utilisé pour attacher un préfixe mailto: aux valeurs de la colonne« Persons.Email ». L'exemple utilise d2rq:uriPattern à la place de d2rq:pattern parce que le pont doit produire des URI et pas de littéraux.

VI-E. Exemple : une propriété-pont qui calcule le hash des boîtes mails

Le populaire vocabulaire FOAF a une propriété foaf:mbox_sha1sum pour publier les adresses mail dans une forme encodée. Ceci empêche les spammeurs de récolter les adresses, tout en nous permettant de savoir si la même adresse mail est utilisée dans deux endroits différents.

 
Sélectionnez
map:UserEmailSHA1 a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:User;
    d2rq:property foaf:mbox_sha1sum;
    d2rq:sqlExpression "SHA1(CONCAT('mailto:', user.email))";
    .

Les valeurs de foaf:mbox_sha1sum sont calculées en évaluant le d2rq:sqlExpression. Nous créons en premier une URI mailto: à partir des adresses mail, comme requis par FOAF. Ensuite nous appliquons la fonction de hash SHA1, encore comme requis par FOAF. Le résultat sera une valeur littérale.

Notez que requêter pour une valeur foaf:mbox_sha1sum spécifique fera peser une lourde charge sur la base de données parce que le hash doit être calculé pour tous les utilisateurs dans la base de données. Pour une base de données volumineuse, il serait mieux de stocker les valeurs encodées dans une colonne dans la base de données.

VI-F. Exemple : une propriété-pont avec des URI générées par une expression SQL

 
Sélectionnez
map:HomepageURL a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:PersonsClassMap;
    d2rq:property foaf:homepage;
    d2rq:uriSqlExpression "CONCAT('http://www.company.com/homepages/', user.username)";
    .

Le modèle mailto:@@Persons.Email@@ est utilisé pour attacher un préfixe mailto: aux valeurs de la colonne « Persons.Email ». L'exemple utilise d2rq:uriPattern à la place de d2rq:pattern parce que le pont doit produire des URI, pas des littéraux.

VI-G. Exemple : lier des instances venant des deux tables de la base de données

 
Sélectionnez
map:PaperConference a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:property :conference;
    d2rq:refersToClassMap map:Conference;
    d2rq:join "Papers.Conference => Conferences.ConfID";
    .

L'exemple attache une propriété :conference aux publications. Les valeurs de la propriété sont générées par l'association de classe map:Conference, non montrée ici. On peut utiliser un d2rq:uriPattern, d2rq:uriColumn ou des nœuds anonymes pour identifier les conférences. L'instance appropriée est trouvée en utilisant d2rq:join sur la clé étrangère Papers.Conference.

VI-H. Exemple : clé étrangère avec de multiples colonnes

Les clés étrangères peuvent traverser de multiples colonnes. Pour créer une propriété qui lie les instances le long de cette clé étrangère, il faut utiliser plusieurs propriétés d2rq:join sur la propriété-pont, une pour chaque paire des colonnes dans la clé :

 
Sélectionnez
map:PaperConference a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:property :journalIssue;
    d2rq:refersToClassMap map:JournalIssue;
    d2rq:join "Papers.Journal => Journal.JournalID";
    d2rq:join "Papers.Issue => Journal.IssueID";
    .

Dans l'exemple, la table Journal a un composant clé constitué de JournalID et IssueID. La contrainte de clé étrangère qui assigne les publications aux journaux couvre deux colonnes, et par conséquent deux d2rq:join sont requis.

VI-I. Exemple : joindre une table à elle-même utilisant d2rq:alias

 
Sélectionnez
map:ParentTopic a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Topic;
    d2rq:property :parentTopic;
    d2rq:refersToClassMap map:Topic;
    d2rq:join "Topics.ParentID => ParentTopics.ID";
    d2rq:alias "Topics AS ParentTopics";
    .

Ici, un sujet peut avoir un sujet parent dont l'ID est trouvé dans la colonne Topics.ParentID. Cette clé étrangère renvoie à la colonne Topics.ID. La table doit être jointe à elle-même. Un d2rq:alias est déclaré, et la jointure est établie entre la table originale et l'alias de la table. Ce modèle est typique des relations hiérarchiques ou de style graphe.

VI-J. Exemple : ajout d'une constante paire propriété-valeur à chaque instance de l'association de classe

Quelquefois il est utile d'ajouter une propriété avec une valeur constante pour chaque ressource qui est créée par une association de classe. Pour réaliser ceci, utiliser un d2rq:PropertyBridge qui utilise d2rq:constantValue :

 
Sélectionnez
map:PersonsClassMap a d2rq:ClassMap;
    d2rq:class :Person;
    .
map:seeAlsoBridge a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:PersonsClassMap;
    d2rq:property rdfs:seeAlso;
    d2rq:constantValue <http://annotation.semanticweb.org/iswc2003/>;
    .

Ceci ajoute une déclaration rdfs:seeAlso avec un objet URL fixé pour chaque instance de l'association de classe map:PersonsClassMap.

VII. Traduire des valeurs (d2rq:TranslationTable)

Une d2rq:TranslationTable est une couche supplémentaire entre la base de données et le monde RDF. Elle traduit dans les deux sens des valeurs prises dans la base de données et des URI ou des littéraux RDF. Une table de traduction peut être attachée à une association de classe ou une propriété-pont en utilisant la propriété d2rq:translateWith. Les tables de traduction ne peuvent être utilisées que pour les associations qui sont uniques dans les deux directions (1:1).

Si les URI produites en utilisant une table de traduction sont également produites ailleurs dans l'association D2RQ sans la même table de traduction (par exemple, à partir d'un d2rq:uriColumn ou d'un d2rq:constantValue), alors les requêtes SPARQL qui font la « jointure » sur ces URI peuvent ne pas fonctionner comme prévu.

VII-A. Propriétés de d2rq:TranslationTable

d2rq:translation

Ajoute une d2rq:Translation dans la table.

d2rq:href

Liens vers un fichier CSV contenant les traductions. Chaque ligne du fichier est une traduction et contient deux chaînes de caractères séparées par une virgule. La première est la valeur de la BDD, la seconde la valeur RDF.

d2rq:javaClass

Le nom qualifié de la classe Java qui effectue l'association. La classe doit implémenter l'interface Translator. Personnaliser des « Translator » pourrait être utile pour l'encodage ou le décodage des valeurs, mais est limité à des traductions 1:1. D'autres détails peuvent être trouvés dans les javadocs de D2RQ.

VII-B. Traduction

Une d2rq:Translation est une entrée dans une d2rq:TranslationTable.

d2rq:databaseValue

Une valeur qui pourrait apparaître dans une colonne de la base de données ou pourrait être générée par un d2rq:pattern.

d2rq:rdfValue

Une traduction de cette valeur pour être utilisée dans les constructions RDF.

VII-C. Exemple: traduire les codes couleur

Une application typique sont les colonnes d'une base de données contenant des codes de type ou des valeurs énumérées similaires. Une table de traduction peut être utilisée pour les transformer en ressources RDF. Dans cet exemple, la colonne ShinyObject.Color contient un code couleur : « R » pour rouge, « G » pour vert, etc. Ces codes doivent être traduits en ressources RDF : :red, :green, etc.

 
Sélectionnez
:red a :Color;
:green a :Color;
# ... plus de couleurs omises ...
:blue a :Color;

map:ColorBridge a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:ShinyObjectMap;
    d2rq:property :color;
    d2rq:uriColumn "ShinyObject.Color";
    d2rq:translateWith map:ColorTable;
    .
map:ColorTable a d2rq:TranslationTable;
    d2rq:translation [ d2rq:databaseValue "R"; d2rq:rdfValue :red; ];
    d2rq:translation [ d2rq:databaseValue "G"; d2rq:rdfValue :green; ];
    # ... plus de traductions omises ...
    d2rq:translation [ d2rq:databaseValue "B"; d2rq:rdfValue :blue; ];
    .

La déclaration d2rq:translateWith indique à D2RQ de rechercher des valeurs de la base de données dans la map:ColorTable. Là, une traduction doit être donnée pour chaque valeur possible. Si la base de données contient des valeurs qui ne sont pas dans la table de traduction, D2RQ ne générera pas une déclaration :color pour cette instance :ShinyObject.

Notez que le type du nœud RDF qui en résulte est déterminé par le pont et non par le type de nœud des rdfValues. map:ColorBridge utilise d2rq:uriColumn. Ainsi, la traduction créera des nœuds d'URI. S'il utilisait d2rq:column, alors des littéraux seraient créés.

VIII. Activation de l'accès HTTP aux CLOB/BLOB (d2rq:DownloadMap)

Certaines bases de données contiennent des fichiers entiers, tels que des PDF ou des PNG, dans les colonnes de la base de données (souvent de type comme BLOB). D2R Server peut rendre le contenu de telles colonnes téléchargeables en utilisant un d2rq:DownloadMap.

Une d2rq:DownloadMap spécifie le nom de la colonne qui contient le contenu téléchargeable, et un modèle d'URI dans l'espace URI du serveur à partir duquel le contenu doit être rendu téléchargeable. Une instance de d2rq:DownloadMap peut avoir les propriétés suivantes :

VIII-A. Propriétés de d2rq:DownloadMap

d2rq:dataStorage

Une instance de d2rq:Database.

d2rq:contentDownloadColumn

La colonne contenant les ressources téléchargeables, sous forme de notation [SCHEMA.]TABLE.COLUMN.

d2rq:uriPattern
d2rq:uriColumn
d2rq:uriSqlExpression
d2rq:constantValue

Spécifient les URI où le serveur rendra téléchargeables les URI disponibles. Les détails sont les mêmes que pour d2rq:ClassMap et d2rq:PropertyBridge. Une seule peut être utilisée.

d2rq:mediaType

Le type media Internet (type MIME) des fichiers servis par cette association de téléchargement. Ceci sera envoyé dans l'en-tête HTTP Content-Type. Les exemples incluent application/pdf, image/png, text/plain et text/html. En cas d'absence, application/octet-stream sera envoyé pour indiquer un fichier binaire générique. La valeur peut être obtenue à partir de la base de données en utilisant la syntaxe d2rq:pattern (voir exemple).

d2rq:condition
d2rq:join
d2rq:alias

Même signification que d2rq:ClassMap et d2rq:PropertyBridge

d2rq:belongsToClassMap

Peut être utilisé à la place de d2rq:dataStorage pour pointer vers une instance d2rq:ClassMap existante. Le stockage des données de l'association de classe sera utilisé. Toutes les conditions, les jointures et les alias de l'association de classe seront hérités de l'association de téléchargement. Cela facilite l'utilisation d'une ressource à la fois comme association de téléchargement et comme propriété-pont. Voir exemple.

VIII-B. Exemple: rendre les PDF téléchargeables

Dans l'exemple suivant, la colonne PAPER.PDF est supposée contenir des fichiers PDF.

 
Sélectionnez
map:PaperDownload a d2rq:DownloadMap;
    d2rq:dataStorage map:database;
    d2rq:uriPattern "downloads/@@PAPER.ID@@.pdf";
    d2rq:contentDownloadColumn "PAPER.PDF";
    d2rq:mediaType "application/pdf";
    .

Cette association de téléchargement rend les PDF téléchargeables aux Uri comme http://serverbase/papers/123/download, et les sert avec le type média correct application/pdf.

VIII-C. Exemple: une association de téléchargement combiné avec une propriété-pont

Parfois, l'URI où le contenu téléchargeable devrait également être la valeur d'une propriété de certaines ressources. Pour faire de telles associations facilement, une ressource unique peut être déclarée à la fois comme un d2rq:DownloadMap et comme un d2rq:PropertyBridge. L'association de téléchargement héritera du stockage des données de l'association de classe, ainsi que de toutes les conditions, les alias et les jointures.

 
Sélectionnez
map:PaperDownload a d2rq:DownloadMap, d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:uriPattern "downloads/@@PAPER.ID@@.pdf";
    d2rq:contentDownloadColumn "PAPER.PDF";
    d2rq:mediaType "application/pdf";
    d2rq:property ex:download;
    d2rq:condition "PAPER.PDF IS NOT NULL";
    .

Ceci rend le contenu de la colonne PAPER.PDF téléchargeable aux URI comme http://serverbase/papers/123/download, et en même temps ajoute ces URI comme valeurs des propriétés ex:download aux instances générées par l'association de classe map:Paper.

Notez également la d2rq:condition, qui supprime la création du triplet ex:download si la valeur de PAPER.PDF est NULL.

VIII-D. Exemple: téléchargements dans de multiples formats

Parfois, les fichiers dans la colonne de téléchargement ne sont pas dans un format unique, mais dans de multiples formats, le format étant indiqué dans une colonne supplémentaire. Ceci peut être géré en définissant plusieurs associations de téléchargement avec les d2rq:conditions appropriées.

 
Sélectionnez
map:PaperDownloadPDF a d2rq:DownloadMap;
    d2rq:dataStorage map:database;
    d2rq:uriPattern "downloads/@@PAPER.ID@@.pdf";
    d2rq:contentDownloadColumn "PAPER.DOWNLOAD";
    d2rq:mediaType "application/pdf";
    d2rq:condition "PAPER.FORMAT = 'PDF'";
    .
map:PaperDownloadWord a d2rq:DownloadMap;
    d2rq:dataStorage map:database;
    d2rq:uriPattern "downloads/@@PAPER.ID@@.doc";
    d2rq:contentDownloadColumn "PAPER.DOWNLOAD";
    d2rq:mediaType "application/msword";
    d2rq:condition "PAPER.FORMAT = 'DOC'";
    .

VIII-E. Exemple: type média à partir d'une colonne de la base de données

La d2rq:mediaType d'une association de téléchargement peut être un modèle qui est instancié avec les valeurs d'une colonne :

 
Sélectionnez
map:PaperDownloadPDF a d2rq:DownloadMap;
    d2rq:dataStorage map:database;
    d2rq:uriPattern "downloads/@@PAPER.ID@@";
    d2rq:contentDownloadColumn "PAPER.DOWNLOAD";
    d2rq:mediaType "@@PAPER.MIMETYPE@@";
    .

Alimenter les classes et les propriétés du vocabulaire

Dans l'esprit des données liées, les URI des classes et des propriétés devraient être déréférençables.

Dans un fichier d'association auto-généré par l'utilitaire generate-mapping, les classes et les propriétés ont des QNames comme vocab:TableName et vocab:TableName_ColumnName. Le préfixe vocab: se développe en URI relative à l'URI de base du serveur, donnant des URI comme http://baseURI/vocab/TableName. Ces URI peuvent être déréférencées dans D2R Server.

Par défaut, la seule déclaration de ces URI est une déclaration rdf:type qui déclare l'URI comme une rdfs:Class ou une rdf:Property. Cependant, d'autres déclarations peuvent être ajoutées dans le fichier d'association. Ceci est fait en ajoutant des propriétés supplémentaires, décrites dans cette section, à l'association de classe ou à l'association de propriété. L'association suivante illustre l'usage attendu :

 
Sélectionnez
@prefix vocabClass: <http://localhost:2020/vocab/resource/class/> .
@prefix vocabProperty: <http://localhost:2020/vocab/resource/property/> .

map:offer a d2rq:ClassMap;
    d2rq:classDefinitionLabel "Offer"@en;
    d2rq:classDefinitionComment "This is an offer"@en;
    d2rq:class vocabClass:Offer;
    .

Quand déréférencée, http://localhost:2020/vocab/resource/class/Offer retournera le label et le commentaire spécifié ainsi que le type rdfs:Class automatiquement inféré. Notez que les préfixes sont attachés à des URI absolues parce que les URI relatives seraient basées sous http://localhost:2020/resource/.

Cette fonctionnalité n'est valable que pour des modèles (URI, TOUT, TOUT) ou (TOUT, TOUT, URI) simples à trouver et qui touchent les ressources du vocabulaire. En d'autres termes, elle ne fonctionne que dans le cas d'un déréférencement de l'URI de la classe ou de la propriété, ou dans le cas d'une description de l'URI en utilisant une requête SPARQL DESCRIBE. Elle ne fonctionne pas actuellement dans d'autres requêtes SPARQL telles que SELECT ou CONSTRUCT.

VIII-F. Labels et commentaires pour les termes d'un vocabulaire

Un rdfs:label peut être ajouté à un terme URI en ajoutant d2rq:classDefinitionLabel ou d2rq:propertyDefinitionLabel à l'association de classe ou à l'association de propriété.

Un rdfs:comment peut être ajouté en ajoutant d2rq:classDefinitionComment et d2rq:propertyDefinitionComment à l'association de classe ou à l'association de propriété.

D'autres propriétés peuvent être ajoutées en créant une construction d2rq:AdditionalProperty, décrite ci-dessous, et en la liant à partir de l'association de classe ou de l'association de propriété en utilisant d2rq:additionalClassDefinitionProperty et d2rq:additionalPropertyDefinitionProperty.

VIII-G. AdditionalProperty

Une construction d2rq:AdditionalProperty peut être utilisée pour ajouter une déclaration fixée à toutes les définitions de classes d'une association de classe, ou à toutes les définitions de propriétés d'une propriété-pont. La déclaration est ajoutée aux ensembles de résultats, si des modèles comme (TOUT, TOUT, TOUT), (URI, TOUT, TOUT) ou (URI, additionalPropertyName, TOUT) sont utilisés. L'utilisation de d2rq:AdditionalProperty pour ajouter les données d'instances est maintenant obsolète (détails). Les propriétés d2rq:additionalClassDefinitionProperty et d2rq:additionalPropertyDefinitionProperty sont utilisées pour lier l'association de classe ou la propriété-pont à la définition d2rq:AdditionalProperty.

d2rq:propertyName

La propriété RDF pouvant être utilisée comme prédicat de toutes les déclarations fixées.

d2rq:propertyValue

La valeur pouvant être utilisée comme objet de toutes les déclarations fixées.

VIII-H. Exemple: fournir une propriété supplémentaire pour la définition de classe

 
Sélectionnez
map:PersonsClassMap a d2rq:ClassMap;
    d2rq:class :Person;
    d2rq:additionalClassDefinitionProperty map:PersonEquivalence;
    .
map:PersonEquivalence a d2rq:AdditionalProperty;
    d2rq:propertyName owl:equivalentClass;
    d2rq:propertyValue foaf:Person;
    .

Ceci ajoute une déclaration owl:equivalentClass avec l'objet fixé foaf:Person pour chaque définition de classe liée.

VIII-I. Exemple: fournir une propriété supplémentaire pour une définition de propriété

 
Sélectionnez
map:PaperTitle a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:property :title;
    d2rq:column "Papers.Title";
    d2rq:additionalPropertyDefinitionProperty map:PaperTitleEquivalence;
    .
map:PaperTitleEquivalence a d2rq:AdditionalProperty;
    d2rq:propertyName owl:equivalentProperty;
    d2rq:propertyValue dc:title;
    .

Ceci ajoute une déclaration owl:equivalentProperty avec l'objet fixé dc:title pour chaque définition de propriété liée.

VIII-J. Contrôler l'alimentation du vocabulaire

L'alimentation du vocabulaire est activée par défaut. Afin de la désactiver, un bloc d2rq:Configuration avec la propriété d2rq:serveVocabulary définie à false doit être créé :

 
Sélectionnez
map:Configuration a d2rq:Configuration;
    d2rq:serveVocabulary false.

Associations conditionnelles

Quelquefois seules certaines informations venant de la base de données doivent être accessibles, car des parties de la base de données peuvent être confidentielles ou erronées. En utilisant d2rq:condition vous pouvez spécifier des conditions qui doivent être satisfaites par toutes les données accessibles.

Vous pouvez utiliser d2rq:condition au niveau d'une association de classe et d'une propriété-pont. La valeur de d2rq:condition est ajoutée comme une clause SQL WHERE à toutes les requêtes générées en utilisant l'association de classe ou la propriété-pont. Si la condition est évaluée à FAUX pour une ligne de l'ensemble d'un résultat SQL, alors aucun triplet ne sera généré à partir de cette ligne.

VIII-K. Exemple : utiliser d2rq:condition sur une d2rq:ClassMap

 
Sélectionnez
map:Paper a d2rq:ClassMap;
    d2rq:class :Paper;
    d2rq:uriPattern "http://www.conference.org/conf02004/paper#Paper@@Papers.PaperID@@";
    d2rq:condition "Papers.Publish = 1";
    d2rq:dataStorage map:Database1;
    .

Seules les publications avec une valeur de 1 dans la colonne Papers.Publish seront accessibles. Toutes les autres publications seront ignorées.

VIII-L. Exemple : filtrer les chaînes de caractères vides

Habituellement, la valeur spéciale NULL est utilisée dans la base de données pour indiquer qu'un champ n'a pas de valeur, ou que la valeur est inconnue. Quelques bases de données, cependant, utilisent une chaîne de caractères vide ("") à la place. D2RQ ne génère pas de déclarations RDF à partir des valeurs NULL, mais il ne reconnaît pas les chaînes de caractères vides et générera des déclarations comme « :Person123 :firstname "". » si le prénom est une chaîne de caractères vide. Afin de supprimer ces déclarations, une d2rq:condition peut être ajoutée à la propriété-pont :

 
Sélectionnez
map:PersonsClassFirstName a d2rq:PropertyBridge;
    d2rq:property :firstName;
    d2rq:column "Persons.FirstName";
    d2rq:belongsToClassMap map:PersonsClassMap;
    d2rq:condition "Persons.FirstName <> ''";
    .

Exemple : codes d'un type de relation

Imaginez une table Rel_Paper_Topic qui associe les lignes d'une table Papers avec des lignes d'une table Topics. La table Rel_Paper_Topic contient une colonne PaperID pour référencer les publications, un TopicID pour référencer les sujets et une colonne RelationshipType qui contient 1 si le sujet est le sujet principal de la publication, et 2 si c'est un sujet secondaire.

Pour les relations d'un sujet principal, la propriété :primaryTopic doit être utilisée, et pour les autres la propriété :secondaryTopic.

On peut construire une association pour ce scénario en créant deux propriétés-ponts. Une pour :primaryTopic, une pour :secondaryTopic. On ajoute une d2rq:condition à ces deux ponts pour supprimer les déclarations où la colonne RelationshipType n'a pas de valeur correcte.

 
Sélectionnez
map:primaryTopic a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:property :primaryTopic;
    d2rq:refersToClassMap map:Topic;
    d2rq:join "Papers.PaperID <= Rel_Paper_Topic.PaperID";
    d2rq:join "Rel_Paper_Topic.TopicID => Topics.TopicID";
    d2rq:condition "Rel_Paper_Topic.RelationType = 1";
    .
map:secondaryTopic a d2rq:PropertyBridge;
    d2rq:belongsToClassMap map:Paper;
    d2rq:property :secondaryTopic;
    d2rq:refersToClassMap map:Topic;
    d2rq:join "Papers.PaperID <= Rel_Paper_Topic.PaperID";
    d2rq:join "Rel_Paper_Topic.TopicID => Topics.TopicID";
    d2rq:condition "Rel_Paper_Topic.RelationType = 2";
    .

Optimisation de la performance en utilisant les propriétés conseils

Cette section couvre les propriétés conseils qui peuvent être ajoutées aux propriétés-ponts afin d'accélérer l'exécution des requêtes : d2rq:valueMaxLength, d2rq:valueRegex et d2rq:valueContains.

Vous gagnerez davantage en performance en fournissant des conseils pour les propriétés-ponts qui utilisent d2rq:column. Vous devez définir des conseils sur les colonnes des grandes tables et sur les colonnes qui ne sont pas indexées par la base de données. Ce sont des cas où une optimisation conseil bien placée peut se traduire par une amélioration significative pour quelques requêtes. Ne vous embêtez pas à fournir des conseils pour les propriétés-ponts basées sur d2rq:pattern. Celles-ci peuvent très bien être optimisées sans conseil. En général, le plus grand gain est attendu pour les conseils sur de grandes tables. Si vous avez quelques très grandes tables avec des colonnes non indexées dans votre base de données, c'est là que vous devriez concentrer vos efforts.

S'il vous plaît, gardez à l'esprit que les propriétés conseils ne sont pas prévues pour filtrer des valeurs inattendues de la base de données. Ce sont seulement des conseils de performance. Les valeurs qui ne remplissent pas les critères apparaîtront toujours dans les résultats de requête si des modèles comme (URI, ANY, ANY) sont utilisés. Afin de filtrer les valeurs, utilisez d2rq:condition ou une table de traduction avec une classe Java personnalisée qui renvoie null pour les valeurs inattendues de la base de données.

VIII-M. Exemple : fournir une longueur maximum

 
Sélectionnez
map:PersonsClassFirstName a d2rq:PropertyBridge;
    d2rq:property :firstName;
    d2rq:column "Persons.FirstName";
    d2rq:belongsToClassMap map:PersonsClassMap;
    d2rq:valueMaxLength "15";
    .

La propriété d2rq:valueMaxLength peut être utilisée pour dire à D2RQ que la longueur des valeurs de Persons.FirstName est limitée à 15 caractères. Utilisant cette information, D2RQ n'a plus à regarder dans la base de données pour comprendre qu'un FirstName donné qui est plus long que 15 caractères ne convient pas.

VIII-N. Exemple : fournir une expression régulière

 
Sélectionnez
map:PaperYear a d2rq:PropertyBridge;
    d2rq:property :year;
    d2rq:column "Papers.Year";
    d2rq:belongsToClassMap map:Paper;
    d2rq:datatype xsd:gYear;
    d2rq:valueRegex "^[0-9]{4}$"
    .

Ici, la propriété d2rq:valueRegex est utilisée pour fournir une expression régulière pour la colonne Papers.Year. La déclaration affirme que toutes les valeurs correspondent à l'expression régulière (ou sont NULL). L'expression ^[0-9]{4}$ correspond à tous les nombres à quatre chiffres. Si vous ne voulez pas utiliser la machine d'expression régulière complète, vous pouvez utiliser d2rq:valueContains pour affirmer que toutes les valeurs générées par la propriété-pont contiennent un certain syntagme.

IX. Construction de langage déconseillé

Cette section énumère quelques constructions de langage venant de vieilles versions de D2RQ qui ont été remplacées par de meilleures et ne devraient donc plus être utilisées.

IX-A. d2rq:DatatypePropertyBridge et d2rq:ObjectPropertyBridge

Les vieilles versions du langage utilisaient deux différentes classes pour la distinction entre les propriétés-ponts qui produisent des littéraux, et les propriétés-ponts qui produisent des ressources.

Dans la version actuelle, les deux cas sont manipulés par la classe d2rq:PropertyBridge. Cette distinction est faite en utilisant une propriété adéquate sur la déclaration du pont : d2rq:column et d2rq:pattern pour les littéraux, d2rq:uriColumn, d2rq:uriPattern et d2rq:bNodeIdColums pour les ressources.

IX-B. d2rq:additionalProperty

Jusqu'à D2RQ 0.5.1, la construction d'une d2rq:AdditionalProperty pouvait être utilisée pour ajouter des paires constante propriété-valeur à toutes les instances d'une association de classe. Un exemple est montré ci-dessous :

 
Sélectionnez
map:PersonsClassMap a d2rq:ClassMap;
    d2rq:class :Person;
    d2rq:additionalProperty map:SeeAlsoStatement.

map:SeeAlsoStatement a d2rq:AdditionalProperty;
    d2rq:propertyName rdfs:seeAlso;
    d2rq:propertyValue <http://annotation.semanticweb.org/iswc2003/>.

Ceci ajoute une déclaration rdfs:seeAlso avec un objet URL fixe pour chaque instance de l'association de classe des personnes. Dans les versions récentes du langage d'association, ceci est réalisé en ajoutant une propriété-pont à l'association de classe, et en lui donnant une propriété d2rq:constantValue avec l'URL fixe comme objet (comme montré dans cet exemple).

Les constructions d2rq:AdditionalPropertysont toujours utilisées avec d2rq:additionalClassDefinitionProperty et d2rq:additionalPropertyDefinitionProperty.

IX-C. les propriétés d2rq:classMap et d2rq:propertyBridges

d2rq:classMap

Spécifie qu'une d2rq:ClassMap est utilisée pour créer des instances d'une classe OWL ou RDFS donnée. Utilisez son inverse, d2rq:class, à la place.

d2rq:propertyBridge

Spécifie qu'une d2rq:PropertyBridge est utilisée pour créer des triplets avec une propriété RDF donnée dans la position de prédicat. Utilisez son inverse, d2rq:property, à la place.

IX-D. d2rq:odbcDSN et d2rq:allowDistinct

Celles-ci sont des propriétés déconseillées de d2rq:Database.

d2rq:odbcDSN

Jusqu'à D2RQ 0.7, la propriété d2rq:odbcDSN pouvait être utilisée sur d2rq:Database pour se connecter à des sources de données ODBC utilisant le pont Sun ODBC-JDBC. Ceci a été déconseillé depuis que les pilotes JDBC sont maintenant facilement disponibles pour la plupart des sources de données et fonctionnent généralement mieux. Les utilisateurs peuvent encore utiliser les sources de données ODBC en téléchargeant un pont ODBC-JDBC à partir d'un fournisseur et l'utiliser comme n'importe quel pilote JDBC, avec un d2rq:jdbcDSN comme jdbc:odbc:mydatabase.

d2rq:allowDistinct

Dans D2RQ jusqu'à la version 0.8, ceci indiquait la capacité de la base de données pour manipuler DISTINCT correctement. Valeur : true ou false. Par exemple MSAccess coupe les champs plus longs que 256 caractères. La propriété n'est plus nécessaire, comme D2RQ détermine désormais la valeur correcte automatiquement.

X. Remerciements

Merci à Richard Cyganiak pour son aide et ses conseils durant la réalisation de cette traduction, à Thibaut Cuvelier pour ses corrections ainsi qu'à ClaudeLELOUP et lejimi pour leur relecture orthographique.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2012-2016 Developpez.com Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.