Le langage d'association D2RQ

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.

@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.

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 :

@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.

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éé.

map:Configuration a d2rq:Configuration;
    d2rq:useAllOptimizations true.

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 :

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.

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 :

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.

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.

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.

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.

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.

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 ».

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é.

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.

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.

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.

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.

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.

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é :

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 JournalIDet 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.

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.

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 :

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.

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

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.

: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.

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

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.

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.

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.

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.

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'";
    .

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

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 :

@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.

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.

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.

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.

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.

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éé :

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.

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.

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 :

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.

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.

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.

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.

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.

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 :

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.

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