Virtuoso

1. Installation
2. Command Lines
3. Reasoning at query time
- 3.1. RDFS (R_a) and OWL
  - 3.1.1. R_a Tests
  - 3.1.2. R_C Test
- 3.2. Custom Inference Rules
  - 3.2.1. Simple Case
  - 3.2.2. Try to reason using domain specification

1. Installation

some instructions: http://vos.openlinksw.com/owiki/wiki/VOS/VOSUbuntuNotes

Welcome to the Emacs shell

maxime@uca-pc [13-07-2023 14:51] /home/maxime/work/org/posts 
└─>sudo apt install virtuoso-opensource

2. Command Lines

2.1. Starting the server

sudo virtuoso-t -fd +configfile /etc/virtuoso/virtuoso.ini

2.2. Data Loading

loading from a file
loading from a url SPARQL LOAD <url>

2.3. List all graph

isql-vt 1111 dba dba exec="SPARQL SELECT  DISTINCT ?g \
   WHERE  { GRAPH ?g {?s ?p ?o} } \
ORDER BY  ?g"

3. Reasoning at query time

The reasoning is done at query time by default. The reasoning is expressed either using an ontology (with default rules) or custom rules.

3.1. RDFS (R_a) and OWL

In the official documentation, we can see that Virtuoso reasoning w.r.t. R_a rules set is limited to:

rdfs7 $\triple{\prop_a}{\subproperty}{\prop_b},\triple{\mathrm{s}}{\prop_a}{\object} \rightarrow \triple{\mathrm{s}}{\prop_b}{\object}$
rdfs9 $\triple{\mathrm{s}}{\subclass}{\object},\triple{\mathrm{s}_1}{\type}{\mathrm{s}} \rightarrow \triple{\mathrm{s}_1}{\type}{\object}$

The reasoning w.r.t. domain and range is not supported.

3.1.1. R_a Tests

I test the reasoning according to subClassOf and subPropertyOf using the query answering test developed for OntoSQL.

clear and load the graph:

isql-vt 1111 dba dba exec="SPARQL 
CLEAR GRAPH <urn:qa-test-graph>;"

isql-vt 1111 dba dba exec="SPARQL 
LOAD <http://pages.saclay.inria.fr/maxime.buron/projects/qa-test/qa-test.nt>
INTO <urn:qa-test-graph>;"

check the data triples:

isql-vt 1111 dba dba exec="SPARQL 
SELECT * 
FROM <urn:qa-test-graph>
WHERE 
{ ?s ?p ?o };"

loading of the ontology

isql-vt 1111 dba dba exec="sparql 
clear graph <urn:qa-test-onto>;"

isql-vt 1111 dba dba exec="SPARQL 
LOAD <http://pages.saclay.inria.fr/maxime.buron/projects/qa-test/qa-test-schema.nt> INTO 
<urn:qa-test-onto>;"

creation of the rules set from the schema

isql-vt 1111 dba dba exec="
DELETE FROM sys_rdf_schema WHERE RS_NAME='urn:owl:inference:rules:qa-test';"

isql-vt 1111 dba dba exec="
rdfs_rule_set('urn:owl:inference:rules:qa-test', 'urn:qa-test-onto');"

list the sets of inference rules:

isql-vt 1111 dba dba exec="SELECT * FROM sys_rdf_schema;"

query type per subject using the reasoning:

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT *
FROM <urn:qa-test-graph>
WHERE { ?s a ?o}
ORDER BY ?s ?o;"

s	o
qa-test:François	qa-test:Thing
qa-test:Ioana	qa-test:Person
qa-test:Ioana	qa-test:Thing
qa-test:Marie-Laure	qa-test:Thing
qa-test:Place	http://www.w3.org/2000/01/rdf-schema#Class
qa-test:contact	http://www.w3.org/1999/02/22-rdf-syntax-ns#Property

The answers set is not correct because François, Ioana and Marie-Laure are of type Person and Person is a subclass of Thing, but only Ioana is of type Thing. We notice that Maxime doesn't have a type, even if the domain of phoneNumber is Person, so domain is not used (the same for range, with Orsay for example).

query all the subject of type Thing (it is correct):

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT *
FROM <urn:qa-test-graph>
WHERE { ?s a <qa-test:Thing>}
ORDER BY ?s ;"

s
qa-test:François
qa-test:Ioana
qa-test:Marie-Laure

query all the types of François (correct also):

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT ?o
FROM <urn:qa-test-graph>
WHERE { <qa-test:François> a ?o }
ORDER BY ?o ;"

o
qa-test:Person
qa-test:Thing

3.1.2. R_C Test

query all the subclass relations, no reasoning seems activated:

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT *
FROM <urn:qa-test-graph>
WHERE { ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o }
ORDER BY ?s ?o ;"

s	o

qa-test:City	qa-test:Place
qa-test:Person	qa-test:Thing
qa-test:Place	qa-test:Thing
qa-test:Thing	qa-test:Thing

We try again by adding first, a triple that declares rdfs:subClassOf as a transitive property. It returns a error, because the transitivity of property is not supported in BGP with a variable as subject.

isql-vt 1111 dba dba exec="SPARQL
INSERT
  {
    GRAPH <urn:qa-test-onto> {
      <http://www.w3.org/2000/01/rdf-schema#subClassOf> a <http://www.w3.org/2002/07/owl#TransitiveProperty> .
    }
  };"

isql-vt 1111 dba dba exec="
rdfs_rule_set('urn:owl:inference:rules:qa-test', 'urn:qa-test-onto');"

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT *
FROM <urn:qa-test-graph>
WHERE { ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o }
ORDER BY ?s ?o ;"

Connected to OpenLink Virtuoso
Driver: 06.01.3127 OpenLink Virtuoso ODBC Driver
OpenLink Interactive SQL (Virtuoso), version 0.9849b.
Type HELP; for help and EXIT; to exit.

*** Error 37000: [Virtuoso Driver][Virtuoso Server]TR...: transitive start not given
at line 0 of Top-Level:
SPARQL DEFINE input:inference 'urn:owl:inference:rules:qa-test' SELECT * FROM <urn:qa-test-graph> WHERE { ?s <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o } ORDER BY ?s ?o

Then we query for super classes of City (should be Place and Thing), but instead it returns a out of memory error,

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT DISTINCT *
FROM <urn:qa-test-graph>
WHERE { <qa-test:City> <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o OPTION (TRANSITIVE)}
ORDER BY ?o ;"

Connected to OpenLink Virtuoso
Driver: 06.01.3127 OpenLink Virtuoso ODBC Driver
OpenLink Interactive SQL (Virtuoso), version 0.9849b.
Type HELP; for help and EXIT; to exit.

*** Error 42000: [Virtuoso Driver][Virtuoso Server]TN...: Exceeded 100000000 bytes in transitive temp memory.  use t_distinct, t_max or more T_MAX_memory options to limit the search or increase the pool
at line 0 of Top-Level:
SPARQL DEFINE input:inference 'urn:owl:inference:rules:qa-test' SELECT * FROM <urn:qa-test-graph> WHERE { <qa-test:City> <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o } ORDER BY ?o

In fact, there are specific settings for transitivity, so we have to specify the distinct near the transitive triples in the query.

isql-vt 1111 dba dba exec="SPARQL
DEFINE input:inference 'urn:owl:inference:rules:qa-test'
SELECT DISTINCT *
FROM <urn:qa-test-graph>
WHERE { <qa-test:City> <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o OPTION (TRANSITIVE, t_distinct)}
ORDER BY ?o ;"

trans-subj-s₃₀	o

qa-test:City	qa-test:Place
qa-test:City	qa-test:Thing

3.2. Custom Inference Rules

The custom inference rules are available only in Virtuoso 8.0, which is the commercial version.

This rules are build using the SPIN (for SPARQL Inference Notation) language.

We define the following sql script in order to test the reasoning in Virtuoso. This script has of three input $GRAPH which the RDF graph that will be loaded, $RULES defining the SPIN rule and $QUERY is the query evaluated in the graph. We notice that the SPIN rule is applied on the class <#Thing>, so the variable ?this in rule definition can only be bound to value in the class <#Thing> (see specification).

cat > .test.sql << EOF
SPARQL DROP SPIN  LIBRARY <urn:rules> ; 
    SPARQL CLEAR GRAPH <urn:graph>
    ;

    SPARQL
    prefix rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>
    prefix rdfs:<http://www.w3.org/2000/01/rdf-schema#>
    WITH <urn:graph>
    INSERT
    {
    $GRAPH
    };
  SPARQL SELECT * FROM <urn:graph> WHERE {?s ?p ?o};


    SPARQL CLEAR GRAPH <urn:rules> ;

    TTLP ('
    ## Collection of Inference Rules that describe
    ## various British Royal Family Relationship Types
    @prefix sp:    <http://spinrdf.org/sp#> .
    @prefix spin:    <http://spinrdf.org/spin#> .
    @prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
    @prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
    @prefix foaf: <http://xmlns.com/foaf/0.1/> .

    <#Thing>
    a rdfs:Class ;
    rdfs:label "A Royal Person"^^xsd:string ;
    rdfs:subClassOf foaf:Person ;
    spin:rule
    [ a sp:Construct ;
    sp:text """
    $RULE
    """
    ] .
    ',
    '', 'urn:rules', 4096)
    ;

    SELECT 
    SPARQL_SPIN_GRAPH_TO_DEFSPIN('urn:rules');

    EXEC ('SPARQL ' || SPARQL_SPIN_GRAPH_TO_DEFSPIN('urn:rules'));
EOF

isql-vt 1111 dba dba exec="LOAD .test.sql" > /dev/null
isql-vt 1111 dba dba exec="SPARQL $QUERY" | tail -n +5

3.2.1. Simple Case

We will consider the following RDF graph:

<Maxime> <livesIn> <Orsay> .
<Maxime> a <#Thing> .

The following SPIN rule says that the object of <livesIn> is of type <Person>.

CONSTRUCT { ?this a <Person> }
WHERE {
{ ?this <livesIn> ?y . }
}

We query for things of type <Person>.

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT ?s
WHERE { ?s a <#Thing> . 
        ?s a <Person> . };

s
Maxime

The SPIN rule have been defined on the class <Thing>, so it seems mandatory to specify the type of <Thing> in the query to activate the reasoning process … So, the answer <Maxime> is missing.

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT *
WHERE { ?s a <Person> .};

s

It is not possible neither to generalize the query as:

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT ?s ?c
WHERE { ?s a <#Thing> . 
        ?s a ?c . };

s	c
Maxime	#Thing

3.2.2. Try to reason using domain specification

We define <Person> as the domain of <livesIn>.

<Maxime> <livesIn> <Orsay> .
<Maxime> a <#Thing> .
<livesIn> <http://www.w3.org/2000/01/rdf-schema#domain> <Person> .

We define the domain reasoning as in the standard:

CONSTRUCT { ?this a ?c }
WHERE {
{ ?this ?p ?y .
  ?p  <http://www.w3.org/2000/01/rdf-schema#domain> ?c . }
}

We query for things of type <Person>.

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT ?s
WHERE { ?s a <#Thing> . 
        ?s a <Person> . };

s
Maxime

The SPIN rule have been defined on the class <Thing>, so it seems mandatory to specify the type of <Thing> in the query to activate the reasoning process …

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT *
WHERE { ?s a <Person> .};

s

In this case, it is possible to generalize the query as:

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT ?s ?c
WHERE { ?s a <#Thing> . 
        ?s a ?c . };

s	c
Maxime	Person
Maxime	#Thing

But, it is not possible to generalize the query as:

DEFINE input:macro-lib <urn:rules>
WITH <urn:graph>
SELECT ?s ?p ?o
WHERE { ?s ?p ?o .};

s	p	o
Maxime	http://www.w3.org/1999/02/22-rdf-syntax-ns#type	#Thing
livesIn	http://www.w3.org/2000/01/rdf-schema#domain	Person
Maxime	livesIn	Orsay