[Alignment format] [API]

EDOAL: Expressive and Declarative Ontology Alignment Language

The Expressive and Declarative Ontology Alignment Language (EDOAL) allows for representing correspondences between the entities of different ontologies. Unlike other formats, the alignment vocabulary allows to represent complex correspondences allowing to precisely describe the relation between the entities. The alignment vocabulary extends the Alignment format.

Purpose

Representing ontology alignments is the general purpose of this vocabulary. Particularly, it extends the ontology Alignment format in order to enable the representation of complex correspondences.

This format can be used for cases where expressing equivalence or subsumption between terms is not sufficient, when more precise relations need to be expressed. While term equivalence or subsumption might be enough for exchanging documents, more precise relations are needed to exchange and integrate data.

This vocabulary was originally designed with the goal of representing patterns of correspondence between ontologies. It was since then both simplified and extended to obtain a minimal vocabulary on top of the Alignment format, able to express all possible kinds of ontology alignments.

Features

The alignment vocabulary has the following features:

The buttons below can be used to show or hide the available syntaxes.

In case of conflict, the RDF/XML syntax is the authoritative one. This is also the one for which we have developed parsers and renderers. However, we are glad that you report errors in the other syntaxes as well.

Support

EDOAL is supported in the following way by the Alignment API:

In addition, it is possible to convert alignments from one format to EDOAL in Java. So far, this is not possible in the command-line interface. This is achieved through the static method EDOALAlignment.toEDOALAlignment( al ); such that al is a BasicAlignment. For this to be possible, the API should be able to access the ontologies concerned by the alignment. An example can be found in the EDOALExport test file.

Alignment and cells

In the Alignment format, an alignment is a set of cells, each cell being a correspondence between two entities. The alignment vocabulary extend this scheme by allowing cells to contain compound entity descriptions. Each entity can be typed according to one of the following category: Class, Instance, Relation, Property. A relation corresponds to an object property in OWL, a property to a datatype property. Each entity can then be restricted, and transformation can be specified on propery values.

While Alignment and Cell are described by the Alignment format, we will focus here on the remaining classes.

Namespaces

The namespace for the Alignment format is still http://knowledgeweb.semanticweb.org/heterogeneity/alignment# (usual prefix: align).

EDOAL's own namespace is http://ns.inria.org/edoal/1.0/ (usual prefix: edoal). EDOAL vocabulary is dereferenceable (see below).

Alignment format

An EDOAL alignment is an alignment as specified by the Alignment format. It is identified by its level which must be "2EDOAL". This tells tools that the alignment is on level 2, i.e., correspondences are across constructed entities, and that the corresponding entities are specified according to the expressive language. This ensures the compatibility with other extensions of the format. The alignment moreover specifies the two aligned ontologies, and as exemplified in the code below.

RDF/XML Syntax
<?xml version='1.0' encoding='utf-8' standalone='no'?> <rdf:RDF xmlns='http://knowledgeweb.semanticweb.org/heterogeneity/alignment#' xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:xsd='http://www.w3.org/2001/XMLSchema#' xmlns:align='http://knowledgeweb.semanticweb.org/heterogeneity/alignment#' xmlns:edoal='http://ns.inria.org/edoal/1.0/'> <align:Alignment> <align:xml>yes</align:xml> <align:level>2EDOAL</align:level> <align:type>**</align:type> <align:method>fr.inrialpes.exmo.align.impl.method.StringDistAlignment</align:method> <align:time>7</align:time> <align:onto1> <align:Ontology rdf:about="http://www.example.org/ontology1"> <align:location>file:examples/rdf/onto1.owl</align:location> <align:formalism> <align:Formalism align:name="OWL1.0" align:uri="http://www.w3.org/2002/07/owl#" /> </align:formalism> </align:Ontology> </align:onto1> <align:onto2> <align:Ontology rdf:about="http://www.example.org/ontology2"> <align:location>file:examples/rdf/onto2.owl</align:location> <align:formalism> <align:Formalism align:name="OWL1.0" align:uri="http://www.w3.org/2002/07/owl#" /> </align:formalism> </align:Ontology> </align:onto2> ...
N3 Syntax
a align:Ontology ; align:formalism [ a align:Formalism ; align:name "OWL1.0" ; align:uri "http://www.w3.org/2002/07/owl#" ] ; align:location "file:examples/rdf/onto1.owl" . a align:Ontology ; align:formalism [ a align:Formalism ; align:name "OWL1.0" ; align:uri "http://www.w3.org/2002/07/owl#" ] ; align:location "file:examples/rdf/onto2.owl" . [] a align:Alignment ; align:level "2EDOAL" ; align:method "fr.inrialpes.exmo.align.impl.method.StringDistAlignment" ; align:onto1 ; align:onto2 ; align:time "7" ; align:type "**" ; align:xml "yes" .

Details on each property are available on the Alignment format page.

An alignment contains a set of correspondences (Cells). Each cell can be linked to an alignment using the map property.

RDF/XML Syntax
... <align:map> <align:Cell> <align:entity1><edoal:Class rdf:about="http://www.example.org/ontology1#entity1" /></align:entity1> <align:entity2><edoal:Class rdf:about="http://www.example.org/ontology2#entity2" /></align:entity2> <align:relation>=</align:relation> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <edoal:transformation>...</edoal:transformation> <edoal:linkkey>...</edoal:linkkey> </align:Cell> </align:map> ...
N3 Syntax
O1:entity1 a edoal:Class . O2:entity2 a edoal:Class . align:map [ a align:Cell ; align:entity1 O1:entity1 ; align:entity2 O2:entity2 ; align:measure "1.0"^^xsd:float ; align:relation "=" ; edoal:linkkey "..." ; edoal:transformation "..." ] ;

A Cell can only have one entity1, entity2, relation and measure property, though it may have several transformation and linkkey properties.

corresp ::= <Cell {rdf:about=" URI "} /> <entity1> entity </entity1> <entity2> entity </entity2> <relation> STRING </relation> <measure> STRING </measure> (<transformation> transformation </transformation>)* (<linkkey> linkkey </linkkey>)* </Cell>

As the example shows, the EDOAL vocabulary only appears within the "entity" properties and very specificaly in the edoal:transformation and edoal:linkkey properties.

The correspondence between the two entities could have been expressed in the simple Alignment format because these have named entities identified by a URI. However, the correspondence provides more information because it tells that these entities are Classes.

The strength of EDOAL is to express more complex entities which are described below.

Entities

A quick overview of the implemented EDOAL API is provided here (abstract classes are in bold and interfaces in italics):

EDOALAlignment extends BasicAlignment
EDOALCell extends BasicCell
Expression
|- ClassExpression
|  |- ClassId implements Id
|  |- ClassConstruction
|  |- ClassRestriction
|     |- ClassDomainRestriction
|     |- ClassOccurenceRestriction
|     |- ClassTypeRestriction
|     |- ClassValueRestriction
|- PathExpression implements ValueExpression
|  |- PropertyExpression
|  |  |- PropertyId implements Id
|  |  |- PropertyConstruction
|  |  |- PropertyRestriction
|  |     |- PropertyDomainRestriction
|  |     |- PropertyTypeRestriction
|  |     |- PropertyValueRestriction
|  |- RelationExpression
|     |- RelationId implements Id
|     |- RelationConstruction
|     |- RelationRestriction
|        |- RelationCoDomainRestriction
|        |- RelationDomainRestriction
|- InstanceExpression implements ValueExpression
   |- InstanceId implements Id
Value implements ValueExpression
Apply implements ValueExpression
Aggregate implements ValueExpression
Transformation
Linkkey
Equals
Intersects
Variable
Comparator
Datatype

The Id interface is implemented by expressions identified by an URI: these are the named entities of ontologies that may be used in basic URIAlignments. The ValueExpression is implemented by expressions that identify in context a particular value or instance. This can be an instance or a literal as well as a path expression that leads to that value in the context of an instance.

Hence, the entities that can be found in cells are:

entity ::= instexpr | classexpr | attexpr attexpr ::= propexpr | relexpr
Below are the syntactic declaration of these entities.

Class expressions

Class entities can be constructed using one of the three operators and, or, not.

A class can also be identified by using its URI or defined through a restriction. There are four types of class restrictions: These four types of restrictions restrict the scope of a class expression by applying a restriction to the value, type or cardinality of a particular property or relation. Restrictions are defined by giving an path expression (relation or property), a comparator defining the relation to a value.

classexpr ::= <Class rdf:about=" URI "/> | <Class> classconst </Class> | <AttributeOccurenceRestriction> onatt comp <value><Literal edoal:type="&xsd;integer" edoal:string="INTEGER" /></value> </AttributeOccurenceRestriction> | <AttributeDomainRestriction> onatt classrest </AttributeDomainRestriction> | <AttributeTypeRestriction> onatt typerest </AttributeTypeRestriction> | <AttributeValueRestriction> onatt comp val </AttributeValueRestriction> classconst ::= <and rdf:parseType="Collection"> classexpr* </and> | <or rdf:parseType="Collection"> classexpr* </or> | <not> classexpr </not>

This grammar relies on base values described in the following table:

onatt ::= <onAttribute> attexpr </onAttribute> typerest ::= <datatype> type </datatype> type ::= <Datatype rdf:about=" URI " /> classrest ::= <class> classexpr </class> comp ::= <comparator rdf:resource=" URI "/>

Comparators have to be defined as specific URI, usually in the edoal namespace. They are currently described by: edoal:equals, edoal:lower-than, edoal:greater-than, the latter morally corresponding to the op:numeric-less-than and op:numeric-greater-than from the XQuery 1.0 and XPath 2.0 Functions and Operators recommendation.

Hence, a class expression may be an identified class:
RDF/XML Syntax
<Class rdf:about="&wine;WineFlavor" />
N3 Syntax
wine:WineFlavor a edoal:Class .
a disjunction or class expressions:
RDF/XML Syntax
<Class> <or rdf:parseType="Collection"> <Class rdf:about="&vin;Acidite" /> <Class rdf:about="&vin;Astreingence" /> <Class rdf:about="&vin;Amertume" /> </or> </Class>
N3 Syntax
vin:Acidite a edoal:Class . vin:Amertume a edoal:Class . vin:Astreingence a edoal:Class . [] a edoal:Class ; edoal:or ( vin:Acidite vin:Astreingence vin:Amertume ) .
Thanks to paths and restrictions, it is possible to restrict a correspondence to ``Wines whose producing region is located in Aquitaine'' using the following restriction:
RDF/XML Syntax
<Class> <and rdf:parseType="Collection"> <Class rdf:about="&vin;Wine" /> <AttributeValueRestriction> <onAttribute> <Property> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Property rdf:about="&proton;name" edoal:lang="fr" /> </compose> </Property> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value><Literal edoal:type="&xsd;string" edoal:string="Acquitaine"/></value> </AttributeValueRestriction> </and> </Class>
N3 Syntax
wine:name a edoal:Property . vin:Wine a edoal:Class . vin:hasTerroir a edoal:Relation . [] a edoal:Class ; edoal:and ( vin:Wine> [ a edoal:AttributeValueRestriction ; edoal:onAttribute [ a edoal:Property ; edoal:compose ( vin:hasTerroir [ proton:name a edoal:Property; edoal:lang "fr" ] ) ] ; edoal:comparator edoal:equals ; edoal:value [ a edoal:Literal ; edoal:type "http://www.w3.org/2001/XMLSchema#string" ; edoal:string "Acquitaine" ] ] ) .

Note that and and or can take no argument. This may be useful in some circumstances. They are interpreted as follows:

Property expressions

Properties correspond to data properties in OWL. Properties entities can be constructed using one of the operators and, or, not and compose:

A property can also be identified by using its URI or defined through a restriction. There are three classes of property restrictions:

propexpr ::= <Property rdf:about=" URI " {edoal:lang=" LANG "}/> | <Property> propconst+ </Property> | <PropertyDomainRestriction> <class> classexpr </class> </PropertyDomainRestriction> | <PropertyTypeRestriction> typerest </PropertyTypeRestriction> | <PropertyValueRestriction> comp val </PropertyValueRestriction> propconst ::= <and rdf:parseType="Collection"> propexpr+ </and> | <or rdf:parseType="Collection"> propexpr+ </or> | <not> propexpr </not> | <compose> relexpr* propexpr </compose>
As previously properties can be identified by its URI:
RDF/XML Syntax
<Property rdf:about="&wine;hasVintageYear" />
N3 Syntax
wine:hasVintageYear a edoal:Property .
But it may also be restricted by a language tag:
RDF/XML Syntax
<Property rdf:about="&proton;name" edoal:lang="fr" />
N3 Syntax
proton:name a edoal:Property ; edoal:lang "fr" .
As previously properties can be assembled by boolean connectors:
RDF/XML Syntax
<Property> <and rdf:parseType="Collection"> <Property rdf:about="&vin;propriétaire" /> <Property rdf:about="&vin;négociant" /> </and> </Property>
N3 Syntax
vin:négociant a edoal:Property . vin:propriétaire a edoal:Property . [] a edoal:Property ; edoal:and ( vin:propriétaire vin:négociant ) .
but they can be obtained through a path, i.e., a sequence of relations ending by a property:
RDF/XML Syntax
<Property> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Property rdf:about="&proton;name" /> </compose> </Property>
N3 Syntax
wine:name a edoal:Property . vin:hasTerroir a edoal:Relation . [] a edoal:Property ; edoal:compose ( vin:hasTerroir wine:name ) .
RDF/XML Syntax
<PropertyTypeRestriction> <datatype> <Datatype rdf:about="&xsd;integer" /> </datatype> </PropertyTypeRestriction>
N3 Syntax
xsd:integer a edoal:Datatype . [] a edoal:PropertyTypeRestriction ; edoal:datatype xsd:integer .

Relation expressions

Relations correspond to object properties in OWL. Relation expressions can be constructed using one of the operators and, or, not and compose as well as "closure" operator inverse, symmetric, transitive and reflexive:

A relation can also be identified by using its URI or defined through a restriction. There are two classes of relation restrictions:

Their syntax is the following:

relexpr ::= <Relation rdf:about=" URI "/> | <Relation> relconst+ </Relation> | <RelationDomainRestriction> <class> classexpr </class> </RelationDomainRestriction> | <RelationCoDomainRestriction> <class> classexpr </class> </RelationCoDomainRestriction> relconst ::= <and rdf:parseType="Collection"> relexpr+ </and> | <or rdf:parseType="Collection"> relexpr+ </or> | <not> relexpr </not> | <compose> relexpr* </compose> | <inverse> relexpr </inverse> | <symmetric> relexpr </symmetric> | <transitive> relexpr </transitive> | <reflexive> relexpr </reflexive>

Domain restriction is exemplified in the following correspondence with relation expression:
RDF/XML Syntax
<align:Cell> <align:entity1> <Relation> <and rdf:parseType="Collection"> <Relation rdf:about="&wine;locatedIn" /> <Relation> <domainRestriction> <Class rdf:about="&wine;Wine" /> </domainRestriction> </Relation> </and> </Relation> </align:entity1> <align:entity2> <Relation rdf:about="&vin;hasTerroir" /> </align:entity2> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <align:relation>&lt;</align:relation> </align:Cell>
N3 Syntax
wine:Wine a edoal:Class . wine:locatedIn a edoal:Relation . vin:hasTerroir a edoal:Relation . [] a align:Cell ; align:entity1 [ a edoal:Relation ; edoal:and ( wine:locatedIn [ a edoal:Relation ; edoal:domainRestriction wine:Wine ] ) ] ; align:entity2 vin:hasTerroir ; align:measure "1.0"^^xsd:float ; align:relation "<" .
An example of occurrence restriction would be the wines produced in a region with no adjacent region, such as an island. For instance Moscatel Madeira wine is produced on the island of Madeira.
RDF/XML Syntax
<align:Cell> <align:entity1> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&wine;Wine" /> <AttributeOccurrenceCondition> <onAttribute> <Relation> <compose rdf:parseType="Collection"> <Relation rdf:about="&wine;hasTerroir" /> <Relation rdf:about="&wine;adjacentRegion" /> </compose> </Relation> </onAttribute> <comparator rdf:resource="&edoal;greater-than" /> <value><Literal edoal:type="&xsd;integer" edoal:string="0"/></value> </AttributeOccurrenceCondition> </and> </Class> </align:entity1> <align:entity2> <Class rdf:about="&vin;Madere" /> </align:entity2> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <align:relation>></align:relation> </align:Cell>
N3 Syntax
wine:Wine a edoal:Class . wine:adjacentRegion a edoal:Relation . wine:hasTerroir a edoal:Relation . vin:Madere a edoal:Class . [] a align:Cell ; align:entity1 [ a edoal:Class ; edoal:and ( wine:Wine [ a edoal:AttributeOccurrenceCondition ; edoal:onAttribute [ a edoal:Relation ; edoal:compose ( wine:hasTerroir wine:adjacentRegion ) ] ; edoal:comparator edoal:greater-than ; edoal:value [ a edoal:Literal ; edoal:string "0" ; edoal:type "http://www.w3.org/2001/XMLSchema#integer" ] ] ) ] ; align:entity2 vin:Madere ; align:measure "1.0"^^xsd:float ; align:relation ">" .
Another example uses a path to state that a locally grown wine is a wine whose owner (propriétaire) is the same person as the first seller (négociant) for this wine.
RDF/XML Syntax
<align:Cell> <align:entity1> <Class rdf:about="&wine;LocallyGrownWine" /> </align:entity1> <align:entity2> <Class> <and rdf:parseType="Collection"> <Class rdf:about="&vin;Vin" /> <AttributeValueRestriction> <onAttribute> <Relation rdf:about="&vin;propriétaire" /> </onAttribute> <comparator rdf:resource="&edoal;equals" /> <value><Relation rdf:about="&vin;négotiant" /></value> </AttributeValueRestriction> </and> </Class> </align:entity2> <align:measure rdf:datatype="&xsd;float">1.0</align:measure> <align:relation>></align:relation> </align:Cell>
N3 Syntax
wine:LocallyGrownWine a edoal:Class . vin:Vin a edoal:Class . vin:négotiant a edoal:Relation . vin:propriétaire a edoal:Relation . [] a align:Cell ; align:entity1 wine:LocallyGrownWine> ; align:entity2 [ a edoal:Class ; edoal:and ( vin:Vin [ a edoal:AttributeValueRestriction ; edoal:onAttribute vin:propriétaire ; edoal:comparator edoal:equals ; edoal:value vin:négotiant ] ) ] ; align:measure "1.0"^^xsd:float ; align:relation ">" .

Note that compose may take no argument in case of relations. This may be useful in some circumstances. <compose rdf:parseType="Collection"/> is equivalent to the identity relation, hence when applied to an object has for unique value the object itself (it is the equivalent self or this in some languages).

Value expressions

A value expression may be used in alignments for denoting an individual things (not a class, a property or a relations). These values may be:

They obey the following grammar:

val ::= <value> value </value> value ::= <Literal {edoal:type=" URI "} {edoal:lang=" LANG "} edoal:string=" STRING " /> | instexpr | attrexpr | <Apply edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Apply> | <Aggregate edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Aggregate> instexpr ::= <Instance rdf:about=" URI "/>

Literal values:
RDF/XML Syntax
<Literal edoal:type="&xsd;integer" edoal:string="123" /> <Literal edoal:lang="fr" edoal:string="Administration" />
N3 Syntax
[] a ; edoal:type "http://www.w3.org/2001/XMLSchema#integer" ; edoal:string "123" . [] a ; edoal:lang "fr" ; edoal:string "Administration" .

Instances are always single entities refering to an individual through its URI:

RDF/XML Syntax
<Instance rdf:about="&vin;hasTerroir" />
N3 Syntax
vin:hasTerroir> a edoal:Instance> .

Application of an operator may be expressed in the following way:
RDF/XML Syntax
<Apply edoal:operator="http://example.com/Whatever"> <arguments rdf:parseType="Collection"> <Literal edoal:type="&xsd;integer" edoal:string="123" /> <Property> <compose rdf:parseType="Collection"> <Relation rdf:about="&vin;hasTerroir" /> <Property rdf:about="&proton;localedIn" /> </compose> </Property> <Instance rdf:about="&vin;Bordelais" /> </arguments> </Apply>
N3 Syntax
proton:localedIn a edoal:Property . vin:Bordelais a edoal:Instance . vin:hasTerroir a edoal:Relation . [] a edoal:Apply ; edoal:operator "http://example.com/Whatever" ; edoal:arguments ( [ a edoal:Literal ; edoal:type "http://www.w3.org/2001/XMLSchema#integer" ; edoal:string "123" ] [ a edoal:Property ; edoal:compose ( vin:hasTerroir proton:localedIn> ) ] vin:Bordelais> ) .

Aggregagtion of a set of values may be defined by (sum the weights of components):
RDF/XML Syntax
<Aggregate edoal:operator="&fn;sum"> <arguments rdf:parseType="Collection"> <Property> <compose rdf:parseType="Collection"> <Property rdf:about="&O1;component" /> <Property rdf:about="&O1;weight" /> </compose> </Property> </arguments> </Aggregate>
N3 Syntax
O1:component a edoal:Property . O2:weight a edoal:Property . [] a edoal:Aggregate ; edoal:operator "http://www.w3.org/2005/xpath-functions#sum" ; edoal:arguments ( [ a edoal:Property ; edoal:compose ( O1:component O1:weight ) ] ) .

The actual implementation of the edoal:operator values is out of the scope of EDOAL. URIs to use as the operator attribute of Apply (and Aggregate) are not specified. Depending on the use of the alignments, operators may be implemented in various way. In order to provide a useful and portable way to express operations, EDOAL promotes the use of the following conventions:

XPath functions (fn:name, op:name and xs:type)
Operators from the XQuery and XPath Functions and Operators (3.1) recommendation. This is the recommended way to identify functions because they have URIs and the XPath library is already quite large. (fn: prefix used for http://www.w3.org/2005/xpath-functions and op prefix used as a convention and does not corresponds to a URI prefix! In addition, the xs: prefix for http://www.w3.org/2001/XMLSchema is used for type coercion as with the "as" operation)
SPIN function (sp:name)
It would be convenient to use standard SPIN functions as well. However, SPIN functions are usually declared in another namespace, e.g., qodtspin, so they may not be usable here (sp: prefix used for http://spinrdf.org/sp? spin for http://spinrdf.org/spin#?)
Web service (http://service prefix)
It should be possible to call a web service (but for this to work parameters should be named and not just listed)
Java (static) method (java:fully qualified class name#method name)
The fully qualified name of a Java method, e.g., java.net.URI#toString, may be used referring to a Java implementation (it can be from any namespace).
Otherwise (uri)
Any URI is possible but its interpretation is undefined.

EDOAL could have come with yet another standard set of built-in functions, but we decided to refrain from introducing it and prefer to rely on more standard efforts.

Transformations

Transformations are expressed in the cell itself. Transformations do not express constraints on the classes or properties, but constraints on instances that should match.

transformation ::= <Transformation edoal:direction=" STRING "> <entity1> value </entity1> <entity2> value </entity2> </Transformation> with STRING ::= 'o-' | '-o'

Transformations can be invoked, for example for dynamic transformations like currency conversions (see examples).

The following correspondence shows an example of the use of data transformation:
RDF/XML Syntax
<transformation> <Transformation edoal:direction="o-"> <entity1> <Property><compose rdf:parseType="Collection"/></Property> </entity1> <entity2> <Apply edoal:operator="concat"> <arguments rdf:parseType="Collection"> <Property rdf:about="vcard:firstname" /> <Literal edoal:type="&xsd;string" edoal:string=" " /> <!-- or even compute middle initial from middlename --> <Property rdf:about="vcard:middleinitial" /> <Literal edoal:string=". " /> <Property rdf:about="vcard:lastname" /> </arguments> </Apply> </entity2> </Transformation> </transformation>
N3 Syntax
vcard:firstname a edoal:Property . vcard:lastname a edoal:Property . vcard:middleinitial a edoal:Property . [] a edoal:Transformation ; edoal:direction "o-" ; edoal:entity1 [ a edoal:Property ; edoal:compose () ] ; edoal:entity2 [ a edoal:Apply ; edoal:operator "concat" edoal:arguments ( [ a edoal:Literal ; edoal:type "http://www.w3.org/2001/XMLSchema#string" ; edoal:string " " ] [ a edoal:Literal ; edoal:string ". " ] ) ; ] .

Linkkeys

Linkkeys which are a generalisation to several data sets of keys in relational databases. A linkkey is a statement such as:

( {⟨p1, q1⟩,... ⟨pn,qn⟩}{⟨p'1, q'1⟩,... ⟨p'm,q'm⟩} linkkey ⟨c, d⟩ )
stating that whatever an instance of the class c has the same values for properties p1,... pn as an instance of class d has for properties q1,... qn and that their values for respectively p'1,... p'm and q'1,... q'm instersect pairwise, then these two are the same entity.

Such keys are slightly more complex than in databases because in RDFelTh-le tr rilway to ideys ( qodtspin> EDOralisat> has t)ey have > and thatURI#toSn be uque vash as a> We caasnt ofject e tr rrecommndfxmltabf restrirlf (rs URIth tlland thatUamedbn these tw (">Link)rticuft>thisr an imtUamedi>m Equsome languhould match.

eansformationeysSTRING "> (tionbipecifon> bipecif/>)*&O1;weight" /> eys > formation">LinkacentRegion" /> eachable1lt;onAttribute> atteachable1ltcentRegion" /> eachable2lt;onAttribute> atteachableu> </entity2> u>att">LinkacentRegion" /|rty> EquacentRegion" /> eachable1lt;onAttribute> atteachable1ltcentRegion" /> eachable2lt;onAttribute> atteachableu> </entity2> u>att Equac= 'o-' | '-o' DFelprim rilwachemaLivr/i>, on instct on (this is that whatever an inNos fi>, on instto bo the sameii>d has for a- ouric, transitire r/i>, os const whismenmcaratoric, transitire l/i>, os const e with ord> Comphese twonts whiecommendaormations are expfxmlDiv"> ence shtransformation:
RDF/XML Syntax
<Proper#ress-form-and </ion"> <ClaLivr/eacute;gone" /> </align:entity1> <ion"> <ClaNos feacute;gone" /> </align:entity2n>></a=ign:relation>></allign:elysSTRItioneysSTRINGgn:elk >plainign:rlk >>STRINGgn:ebipecifo</Property EquacentRegion" eachable1l <Relatia- oureacute;goeachable1l </eneachableu> <Relaticaratoreacute;goeachable2Transfor EquacentRegnsforbipecifo</Prgn:ebipecifo</Property">LinkacentRegion" eachable1l " /> <Properre r/eacute;goeachable1l ion" /> eachable2l " /> <Properre l/eacute;goeachable2 </Property>">LinkacentRegnsforbipecifo</ eys;/ lysign:relation> </align:Cell>
N3 Syntax
EquSchema#string" ; eachable1 O1:a- ourvchema#string" ; eachable al:caratorv],iddleinitial> Earator edoal:equals ; eachable1 O1:re r/>chema#string" ; eachable al:re l/:]:lastname> ) ; ] . | '-o' It should bmended wadurdfxmls on tto s whicte equivalee twAxpath-fand these entities.

er-th="ss/dl> Linkk/dl> < relacont> whiexamp-th=estricted uld haerprean be i

A ng s which a>fulhe following ta se

LL. Properties enabrtiecake no stricted ientionvctiodiffe. Thmiddle/dl> <(beh ord possibfrainual imp mple may>

Linkkeh libra>not are expdfxmlDiv ence sh). | '-o' Cont>/suiv uftyoule y bs a stestricted be> Comessionaer a stadfxmnstancedo.

fxmlDiv"> The following camp-th=ether on. Thmple may>.hmpl3ses. >d hyhmple may
  • notormed d hyh> C fromnd pos lues n instc can also be estricle may hyhmpl3classthat atatypnts wiecommeamp-th=ethuertipturn RD []lhe following taorrespoion. There a,tions restrict whin instbeing the foll, but onle esoatabastraints> C froa be definen; hyh examples).

    RDF/XML Syntax
    <Proper#l"> 1e;Bordeaune" /> </</ ity2> <Class> <and rdf:parseType="Collection"> rer#icl1="&vin;Vin" /> </AttributeTypeRestrictin" / <onAttribute> lt;/RelationCoDom rer#icl3STRING "> <ty2> <NG "> <> rer#icl1="&vin;Viu> "> </;ty2> <NG"Collection"/</AttributeDomainRestricti"Coll </onAttribute> /> te> > <Datatypf:about="&x"Collon> <datatypeerest </AttributeTypeRestrign:re> </and> </Class> </align:entity1> <align:entity2> rer#icl2amp;vin;Madere" /> </align:entity2n>></a=ign:relation>></align:relation> </alig/Class>
    N3 Syntax
    . ].don> &1Relation . [; an:Cell ; a r1; a in:hasTerrPropertyT; edoa r3. ].d ].d wnWine> ; r2.t;/alig/Class>
    GraphClass> &rang ="img/graph-="n3D-form- the oper-n;>d&rang) ; ] . | d="sle may>key3-o' <"sle may>SPIN fuo prout we>not he use oframp-th=>.hy conversions (ssee

    instexp"sle mayamp;vin;Viu> "> <icl_id> la.neign:ricl_id>mp;vin;Viu> "> <icl_bipecifRlt;comparator uriut="&O1;weight" /> "sle mayamex4n3"> sec:extr">LongxmlDiv"> A"keys">LinkVplementDiv"> A"ividualson the use of filhat ttndualson &O1vence shs/omwg" n ; oryer an inAe use of APIets e argzip.i>
  • ence shstcllustrineimplementkidveralusted an invocabulary.i>i3es).

    ex1e;ity2> &ti try3-oi> Acorresprree whations de to restrict a correspoilDiv"> Hals whicntology to restricentitiesother straints oi const e witcntologyin various waygrapse expdfxcdd> to restrict a ,const whin instct &ti y btcto centitieestric Ac whicntology h pref instLED

    Lh pre lolo ic, trthe oper>examples).

    RDF/XML Syntax
    <Proper#ress1e;Bordeaune" /> </</ ity2> <Class> <and rdf:parseType="Collection"> <Property rLED="&vin;Vin" /> <AttributeValueRestriction> <onAttribute> <Relatioy rlasColo iétaire" /> < bute> <comparator rdf:resource="&edoal;equals" /> <Instancy rB</value> </AttributeValueRestriction> </and> </Class> </align:entity1> <ion"> <Cla&O2;B </align:entity2n>></a=ign:relation>></align:relation> <lass="rdfxml"> <Proper#ress2e;Bordeaune" /> </</ ity2> <Class> <and rdf:parseType="Collection"> <Property rLED="&vin;Vin" /> <AttributeValueRestriction> <onAttribute> <Relatioy rlasColo iétaire" /> < bute> <comparator rdf:resource="&edoal;equals" /> <Instancy rRedeacute;gotiant" /></value> </AttributeValueRestriction> </and> </Class> </align:entity1> <ion"> <Cla&O2;RedLEDeacute;gone" /> </align:entity2n>></a=ign:relation>></align:relation> <lass="rdfxml"> <Proper#ress3e;Bordeaune" /> </</ ity2> <Class> <and rdf:parseType="Collection"> <Property rLED="&vin;Vin" /> <AttributeValueRestriction> <onAttribute> <Relatioy rlasColo iétaire" /> < bute> <comparator rdf:resource="&edoal;equals" /> <Instancy rG. Tneacute;gotiant" /></value> </AttributeValueRestriction> </and> </Class> </align:entity1> <ion"> <Cla&O2;G. TnLEDeacute;gone" /> </align:entity2n>></a=ign:relation>></align:relation> </alig/Class>
    N3 Syntax
    GraphClass> &rang