LDPath Language Reference

Filter Definition (search/indexing only)

@filter TEST

The search index will only contain nodes (documents) that pass the defined filter. See Value Testing below.

Boost Definition (search/indexing only)

@boost PATH

apply a document boost based on the given PATH. Must evaluate to float, default is 1.0.

Property Selections

A path definition selecting the value of a property. Either a URI enclosed in <> or a namespace prefix and a local name separated by :

<URI> | PREFIX:LOCAL

Example:

Select the foaf:name property using namespace prefix and local name:

title = foaf:name :: xsd:string ;

Select the foaf:name property using the fully qualified URI

title = <http://xmlns.com/foaf/0.1/name> :: xsd:string;

Reverse Property Selections

This is the reverse/inverse operation of the normal Property Selection.

Select all nodes connected to the current node via an incoming link, aka. go the specified link “backwards”:

^<URI>

Example:

Get the names of all persons that link the current person as foaf:knows:

friends = ^foaf:knows / foaf:name :: xsd:string;

Note, however, that this kind of navigation is not completely supported over the Linked Data Cloud. While it might be against the ethos of RDF, Linked Data restricts these principles. In most cases it is not possible to know the incoming links from external datasets to a resource.

Wildcard Selections

Wildcard selections allow to select the values of all properties of a node. They are expressed by a *:

*

Example:

Select all properties of the resource:

all = * :: xsd:string ;

Path Traversal

Traverse a path by following several edges in the RDF graph. Each step is separated by a /.

PATH / PATH

Where PATH is an arbitrary path selector (e.g. a property selection or test)

Example:

Select the names of all friends:

friend = foaf:knows/foaf:name :: xsd:string;

Unions

Several alternative paths can be merged by using a union | between path elements

PATH | PATH

Where PATH is an arbitrary path selector.

Example:

Select the labels or names of all friends:

friend = foaf:knows/foaf:name | foaf:knows/rdfs:label :: xsd:string;

Intersections

The intersection of several paths can be computed by using an intersection & between path elements

PATH & PATH

Where PATH is an arbitrary path selector.

Example:

Select values that are both defined for foaf:interest and foaf:topic_interest:

topic_interests = foaf:interest & foaf:topic_interest :: xsd:anyURI;

Recursive Selections

Recurseive selection will apply an selectore recursively. The recursion can be limited with lower and upper bounds.

(<SELECTOR>)*
(<SELECTOR>)+
(<SELECTOR>){n,m}
(<SELECTOR>){n,}
(<SELECTOR>){,m}

The specified selector is applied zero-and-more (*), one-and-more (+), n-to-m-times ({n,m}), n-and-more-times ({n,}) and up-to-m-times ({,m}).

Groupings

Path expressions can be grouped to change precedence or to improve readability by including them in braces:

( PATH )

where PATH is an arbitrary path selector.

Example:

Select the labes or names of friends:

friend = foaf:knows/(foaf:name | rdfs:label) :: xsd:string ;

Value Testing

The values of selections can be tested and filtered by adding test conditions in square brackets [] after a path selection:

PATH [TEST]

where PATH is an arbitrary path selector and TEST is a test condition (see below).

@LANGUAGE

title = rdfs:label[@de] | rdfs:label[@none] :: xsd:string ;

^^TYPE

decimals = *[^^xsd:decimal] :: xsd:decimal

PATH is VALUE

food = foaf:interest[rdf:type is ex:Food] :: xsd:anyURI;

PATH

friends = foaf:knows[foaf:name] :: xsd:anyURI;

foodstuff = foaf:interest[rdf:type is ex:Food | rdf:type is ex:Drink] :: xsd:anyURI ;

fluidfood = foaf:interest[rdf:type is ex:Food & rdf:type is ex:Drink] :: xsd:anyURI ;

foodstuff = foaf:interest[rdf:type is ex:Food]/rdfs:label[@es] :: xsd:string ;

Builtin: String Concatenation

String concatenation is a very frequently needed function and is already built in:

Concatenate the foaf:given and foaf:surname of all friends:

friends = foaf:knows/fn:concat(foaf:given," ",foaf:surname) :: xsd:string ;

Combination of concatenation and union:

friends = foaf:knows/(fn:concat(foaf:given," ",foaf:surname) | foaf:name) :: xsd:string ;

Builtin: List Operation (First and Last)

Selects the first (last) non-empty argument.

label = fn:first(skos:prefLabel[@de], skos:prefLabel) :: xsd:string ;

Builtin: String Cleansing

Removes all html/xml tags from the string representations of the arguments.

content = fn:removeTags(ex:hasHtmlContent) :: xsd:string ;

Builtin: XPath

Nodes are transformed into string representation and interpreted as XML. Given XPath expression is evaluated on these XML-Docs.

title = fn:xpath("//head/title/text()", ex:hasHtmlContent) :: xsd:string ;

Builtin: Resource Content

In some cases you will want to retrieve the human-readable content (e.g. in HTML) that is associated with a resource, e.g. a website. The RDF Path language has a builtin function to achieve this goal:

content = fn:content(.) :: lmf:text_en ;

would retrieve the content of the current resource and index it as English text. Arbitrary paths can be used, so this function can also be used to retrieve the content of resource selected by more complex path selections:

homepage_content = fn:content(foaf:homepage) :: lmf:text_en ;

would retrieve the homepage of a foaf:Person and index it as English text.