Semi Automatic Construction of ShEx and SHACL Schemas

by   Iovka Boneva, et al.

We present a method for the construction of SHACL or ShEx constraints for an existing RDF dataset. It has two components that are used conjointly: an algorithm for automatic schema construction, and an interactive workflow for editing the schema. The schema construction algorithm takes as input sets of sample nodes and constructs a shape constraint for every sample set. It can be parametrized by a schema pattern that defines structural requirements for the schema to be constructed. Schema patterns are also used to feed the algorithm with relevant information about the dataset coming from a domain expert or from some ontology. The interactive workflow provides useful information about the dataset, shows validation results w.r.t. the schema under construction, and offers schema editing operations that combined with the schema construction algorithm allow to build a complex ShEx or SHACL schema.



There are no comments yet.


page 1

page 2

page 3

page 4


Janus: Automatic Ontology Builder from XSD Files

The construction of a reference ontology for a large domain still remain...

The Extended Dawid-Skene Model: Fusing Information from Multiple Data Schemas

While label fusion from multiple noisy annotations is a well understood ...

Typed Image-based Programming with Structure Editing

Many beloved programming systems are image-based: self-contained worlds ...

Not Elimination and Witness Generation for JSON Schema

JSON Schema is an evolving standard for the description of families of J...

Schema Curation via Causal Association Rule Mining

Event schemas are structured knowledge sources defining typical real-wor...

ML-Schema: Exposing the Semantics of Machine Learning with Schemas and Ontologies

The ML-Schema, proposed by the W3C Machine Learning Schema Community Gro...

SHACL Constraints with Inference Rules

The Shapes Constraint Language (SHACL) has been recently introduced as a...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

With the growth in volume and heterogeneity of the data available in the Linked Open Data Cloud, the interest in developing unsupervised or semi-supervised methods to make this information more accessible and easily exploitable keeps growing as well. For instance, RDF graph summarization [1] is an important research trend that aims at extracting compact and meaningful information from an RDF graph with a specific purpose in mind such as indexing, obtaining high level descriptions of a given dataset, graph visualization, query optimization, or extracting a schema or an ontology.

The Shapes Constraint Language (SHACL) [6] is the W3C standard for defining constraints for RDF graphs. The Shape Expressions Schemas (ShEx) language  [14] has a similar purpose but is based on a slightly different set of operators. Both proposals allow to define a set of named shapes that constrain the RDF nodes and describe their close neighbourhoods. A set of such constraints is called a schema and provides high level information about the structure and contents of an RDF dataset. Such schema is usually constructed with a particular application in mind. SHACL and ShEx schemas allow to increase RDF datasets usability, as they facilitate RDF validation, understanding and querying.

More recently, several authors have used techniques close to graph summarization in order to automatically produce a SHACL [12, 15, 10] or a ShEx [2, 16, 7, 4] schema. Nevertheless, shapes generated using noisy or incomplete data may contain incorrect data or imprecisions. Most of the times, the shapes should be reviewed and edited by domain experts in order to ensure they fit with the application requirements. The usability of tools letting a proper edition of those schemas has been identified as a challenge [8]. The relative youth of consolidated constraint languages for RDF data causes that this kind of tools has not been thoroughly investigated yet, but a list of desirable features has been proposed [3].


In the current paper we describe the algorithms and the software components that are necessary for the development of an integrated, highly parametrizable and well automated tool that would allow to users with different levels of expertise to construct SHACL and ShEx schemas from data. As a first contribution, we define an algorithm that takes as input a set of sample nodes from the RDF dataset and outputs a so called uniform shape constraint that uses only a restricted number of features of ShEx and SHACL. The uniform constraint can either be satisfied by all the nodes in the sample, in which case it is the unique most specific such constraint. Or it can take into account possible noise in the data and be satisfied by most sample nodes except for a small number of them consistent with a predefined error threshold. As a next contribution, we introduce schema patterns as a general mechanism for guiding and tuning our schema construction algorithm. A schema pattern can be provided as input to the algorithm, in which case the latter can output a complex shapes schema with nested constraints and references between shapes. In particular, we show how to construct a schema pattern from an existing ontology so that the automatically constructed schema contains one shape for each class in the ontology and integrates the predicates’ domain and range axioms. We finally describe an interactive workflow that allows to construct an arbitrarily complex schema with the help of appropriate schema edition operators, statistical information about the data, a comprehensive visualization of validation results, and integrated calls to the algorithm for automatic schema construction.

Most of the ideas presented here are already implemented in the open source java tool ShapeDesigner available at

Related work

RDF2Graph [2] performs structural graph summarization on knowledge bases that can be exported to RDF, OWL, XGMML or ShEx. By default, this tool associates shapes to classes, taking into account class hierarchies. However, some tuning is possible, allowing to define constraints for sets of nodes that do not belong to the same class. It is limited w.r.t. expressible cardinalities but considers incoming and outgoing links in the neighbourhood of nodes. The resulting summary can be exported to ShEx or visualized as a graphical network, but none of these options are intended to be edited or refined by the user.

RDF2Graph has been used as a base to perform shape construction in Wikidata [16], using a publicly available tool111 retrieved on 2019/04/11.. This tool allows to specify an initial custom set of focus nodes to be associated with a shape. It can relate other shapes to the initial one, being those shapes constructed w.r.t nodes of the same class. It ignores triples in reified models, thus the schema of the metadata associated to a given piece of knowledge in Wikidata is missed.

In [4] and [7] the same authors propose two tools for automatic generation of ShEx schemas, which can be partially translated to SHACL in [7]. The tool in [4] takes as input a set of classes of a Knowledge Base (KB) and produces a ShEx shape for each one computing the immediate neighbourhood of the instances of that class. It uses statistical methods to choose the neighbourhood constraints, being able to discard the infrequent constraints and providing statistical annotations about them. The approach presented in [7] is independent of classes and the resulting constraints go beyond the immediate neighbourhood, but it is more limited w.r.t. cardinalities and less parametrizable. None of those proposals define an interaction process, and they are both less parametrizable than our method w.r.t. the structure of the schemas to be constructed.

The tool presented in [12] detects sets of nodes of an RDF graph that match some patterns, then combines those patterns to construct more complex OWL 2 EL class expressions and axioms. The latter can be exported to SHACL. The node groupings used for defining a shape are not necessarily related to the same class nor selected by the user, but they are automatically detected by the mining algorithm.

ABSTAT [13] is an ontology-driven tool able to produce semantic profiles of a given Knowledge Base (KB). Those profiles gather statistics about type and cardinality of features in the immediate incoming or outgoing neighbourhood of a set of target nodes. In [15], ABSTAT’s profiles are translated to SHACL shapes associated to the instances of some target class.

PaTyBRED [11]

is a hybrid classifier method which relies on path and type relations for the detection of errors in KBs. In 


, the authors train decision trees using PaTyBRED to generate SHACL constraints. The core idea is to detect examples qualified as highly erroneous, turn them into logical conditions and use their negation as a constraint.

The novelties of our approach compared to those cited above are (1) we include a strategy to integrate the user in the refinement of the automatically constructed schemas; and (2) we introduce schema patterns as an expressive parametrization mechanism. This allows to feed the schema construction algorithm with useful information coming from an ontology, or with expert knowledge.


In Sect. 2 we introduce a shapes schema language as an abstraction of ShEx and SHACL. In Sect. 3 we define uniform schemas as restriction of the language and explain the construction of the most specific and the largely accepted consensus uniform constraints. Schema patterns are defined in Sect. 4 and the interactive workflow in Sect. 5. We also discuss there the current status of the implementation of the method presented in this paper. We finally conclude and discuss future work in Sect. 6. This submission is accompanied by a long version extended with two appendices.

2 The Shape Constraint Language

We assume that the reader is familiar with RDF and has at least some basic understanding of the SHACL and ShEx constraint languages. We start by fixing notations related to RDF graphs then present the shapes constraint language.

Denote by the set of IRIs, by the set of literal values, and by the set of blank nodes. Recall that an RDF graph is a set of triples in . If is a triple, then is the subject, the predicate, and the object of the triple. A graph will be clear from the context all along the paper. The elements of that appear in subject or object position of some triple of are called nodes, and the elements that appear in predicate position are called predicates or also properties. If is a set of nodes, we define , i.e. the set of properties of the nodes in . The neighbourhood of a node is the set of triples of with subject . Node is called a -neighbour of node if is a triple in . Throughout the paper we use IRI prefixes without defining them and assume that different prefixes (e.g. p: and q:) always have different definitions.

SHACL [6] and ShEx [14] are the two main languages used for defining constraints for RDF graphs. See [9] for an introduction to these languages. They both use the notion of shape in order to describe or constraint the neighbourhood of nodes in RDF graphs, as illustrated in Example 1.

Example 1 (The shapes <Person> and <Date>)

The shape <Person> requires 1) an rdf:type link to foaf:Person; 2) zero or more owl:sameAs links to some IRI; 3) a foaf:name link and a foaf:familyName link to string literals; and 4) a bio:birth link to a xsd:gYear or a rdgr2:dateOfBirth link to a node that satisfies shape <Date>, but not both. On the other hand, shape <Date> requires 1) an rdf:type link to time:Instant; and 2) an rdfs:label that is an integer value. This is how the constraint for shape <Person> would be written in the shapes constraint language.

{  rdf:type [foaf:Person] {1;1};    owl:sameAs IRI {0;*} ;
   foaf:name xsd:string {1;1};      foaf:familyName xsd:string {1;1} ;
   ( bio:birth xsd:gYear {1;1} | rdgr2:dateOfBirth @<Date> {1;1} ) }

In Appendix A we show how these shapes are expressed in ShEx and SHACL.

In Fig. 1 we provide some turtle content with a couple of nodes to be validated against the shape <Person>. :virginia conforms with <Person>, since it includes all the requested features regarding outgoing links. Shapes are open in the sense that they allow nodes to have outgoing links with predicates that are not mentioned in the shape, as for instance the property rdgr2:placeOfBirth of :virginia. :william does not conform, since the information about Williams’ name is provided using schema:name instead of foaf:name and foaf:familyName. In addition, :william also violates the requirement that only one among bio:birth or rdgr2:dateOfBirth links should be present.∎

ex:virginia a foaf:Person ;          ex:william a foaf:Person ;
  foaf:name "Virginia" ;               owl:sameAs wd:Q692 ;
  foaf:familyName "Woolf" ;            schema:name "William Shakespeare" ;
  bio:birth "1882"^^xsd:gYear ;        rdgr2:dateOfBirth bnf:1564 ;
  rdgr2:placeOfBirth "London" .        bio:birth "1564"^^xsd:gYear .
bnf:1564 a time:Instant ;  rdfs:label 1564 .
Figure 1: Nodes of type foaf:Person

We now introduce the abstract Schapes Constraint Language (SCL) that containing the main features of ShEx and SHACL and has a quite straightforward translation to both of them described in Appendix A of the long version. Its syntax is very similar to ShEx compact syntax. A shape constraint is defined by the abstract syntax in Fig. 2 using Extended Backus–Naur Form (EBNF) where the symbol ‘*’ denotes the repetition of an element zero or more times. We next explain the semantics of SCL.

  ( ‘AND’  )*      
an XML Schema type constant
an IRI interpreted as a prefix or an RDF prefix with its terminating :
a list of comma separated s or literals
  (    )*
a label in
Figure 2: Syntax of the constraint language.

A is satisfied by a node if this node and its neighbourhood satisfy both the value and the neighbourhood constraints. Each restricts the value of a node to be one of the options in , where denotes a literal, a non-literal, a blank node, any IRI, and imposes no value restriction, defines a required XML Schema Definition type of the value, imposes it to be an IRI with the given prefix, and enumerates the admissible values. A is satisfied by a node if its neighbourhood satisfies all the conjuncts. A is satisfied when just one of the s composing it is satisfied. A is to be satisfied by the triples in the neighbourhood of the node having the specified predicate. The number of such triples must fit within the cardinality bounds given by and , where is a natural and is either a natural or the special value ’’ for unbounded cardinality. The objects of those triples should be nodes satisfying the specified , which can be a simple or another shape. The latter is either a reference to or a nested shape with {}. Note finally that a constrains only the triples in the neighbourhood which predicate is mentioned in one of its . All other predicates can be present without restriction on their object value or cardinality.

A schema is a pair where is a finite set of shape labels and associates with every label in its definition which is a shape constraint. How an RDF graph should conform to a schema is defined by a validation target. A validation target for schema and graph is a pair where associates a set of nodes of with every shape label from . We say that graph satisfies schema with target if for any shape label in , all nodes in satisfy the constraint . Most typically, a target is specified using a class from an ontology or a SPARQL query. For instance, one might want to validate all nodes with class City and population greater than 1 million people against a shape <BigCity>. In this paper we consider non-recursive schemas only that do not allow the definition of a shape label to refer to itself neither directly nor transitively.

3 Automatic Construction of Uniform Constraints

Consider a fixed RDF graph . In this section we address the problem of automatically constructing a shape constraint to be satisfied by a given sample set of nodes of . We define uniform constraints which enjoy the nice property that for any set of sample nodes , there exists a unique most specific uniform constraint satisfied by all the nodes in (see Sect. 3.1). We also explain how to construct a uniform constraint satisfied by most but not necessarily all sample nodes, thus allowing to take into account noise in the sample data (see Sect. 3.2).

A uniform constraint is defined by the syntax in Fig. 3. We additionally require that the s that appear in the same are without repeated properties, i.e. their predicates are pairwise distinct. Intuitively, uniform constraints allow to enumerate the predicates to appear in the neighbourhood of a node and to specify for each predicate a constraint for its value and its cardinality among a restricted choice of four possible cardinalities. Remark that uniform constraints belong to the SCL language defined in Sect. 2.

  (    )*
single IRI or literal
Figure 3: Syntax of uniform constraints.

3.1 Most Specific Constraint

Let be the set of all constraints definable by s and let be the (partial) ordering relation over defined by if all nodes that satisfy also satisfy . Then for any prefix and for any XSD datatype it holds

Moreover, is defined for prefix constraints by if is a prefix of , and also for XSD datatypes, for instance . Finally, is defined for constraints by if is a literal and is its XSD type; if is an IRI and is its longest prefix, and if is a blank node.

Let be the set of uniform cardinalities, then the subset relation on intervals defines an ordering relation over . It is not hard to show that

Lemma 1

is an upper semilattice with least upper bound . is a complete lattice with least upper bound and greatest lower bound .

Therefore, for any set of RDF nodes , there exists a unique most specific uniform value constraint satisfied by all nodes in that we denote by . Similarly, for any set of natural numbers, there exists a unique most specific uniform cardinality that includes and we denote it .

Definition 1 (Most specific constraint)

Let be a sample set of nodes. The most specific constraint associated with is the uniform constraint that contains exactly one for every predicate whose value constraint and cardinality satisfy:

  • where is the set of -neighbours of ;

  • where .

It easily follows from the definition that

Lemma 2

For any sample , it holds that satisfies the schema with target .

The schema defined in Lemma 2 is the most precise schema using uniform constraints that one can construct for matching with the nodes of the sample .

3.2 Largely Accepted Consensus Constraint

The largely accepted consensus constraint allows to account for potential errors in the neighbourhoods of the sample nodes. Imagine that most -neighbours of the nodes in have an value, except for a very small number of them whose value is a literal. In this case, will consider as value constraint for , while it is also possible that the literal -neighbours are errors in the data.

We start by presenting a decision making algorithm used in the definition of the largely accepted consensus constraint. Assume a non-empty set of options to choose from by a finite set of voters , and let be an upper semilattice with least upper bound , where indicates that if option is acceptable for given voter, then is acceptable for him/her as well. Every individual votes for its preferred option , and let be the number of voters that consider option as acceptable. Formally, for any total function , we define . It is then easy to see that is the total number of votes, i.e. .

Let be a threshold value. We define the consensus option that is acceptable for at least a proportion of the voters. Let be the least value in the range of s.t. is above the threshold. Then

Note that, by definition, is uniquely defined for all semilattices , sets of voters , vote functions and thresholds .

Example 2 (Consensus)

Below on the left, consider the tree (thus also upper semilattice) with , where is a child of whenever . Assume a set of 20 voters and a voting function . For every option we give between parentheses where is the number of direct votes (i.e. ) and . Then for different values of the threshold we obtain: , and . Below on the right is presented the latitice , again annotated with as above for a set of 20 voters and a voting function . Then .











The largely accepted consensus constraint is defined using a consensus where the voters are (some of) the nodes of the sample . For every , let be the set of sample nodes that have at least one -neighbour and assume we are given:

  • a vote function that gives the preferred value constraint for property of every sample node that has a -neighbour;

  • a vote function that gives the preferred cardinality for property of every sample node.

Definition 2 (Largely accepted consensus constraint)

Let be a sample set of nodes and be an error rate value. The largely accepted consensus constraint associated with and assuming error rate is the uniform constraint that contains exactly one for every predicate and it has value constraint , and cardinality . ∎

The error rate value is intuitively a bound on the proportion of sample nodes that could have expressed an incorrect222Incorrect w.r.t. a supposedly existing correct uniform constraint that the user aims at. vote due to noise in the data. It is not hard to see that .

Finally we define the vote functions and . For any node and any , is defined as follows, where is the number of -neighbours of :

As for , it is itself defined as a consensus: where is an error rate that might be different from , the voters are all -neighbours of , and the voting function is defined by (i.e. the singleton containing ).


The and constraints are implicitly parametrized by that could be replaced by any upper semilattice. For instance, might be sufficient for some use cases. We choose to present this particular value for because it is useful in practice.

4 Schema patterns

wd:Q37100 a wikibase:Item ;
   wdt:P17 wd:Q664 ;                  %{\it\color{gray} \# (ds) country: New Zealand}p:P17 [ a wikibase:Statement ;           ps:P17 wd:Q664 ;                 %{\it\color{gray} \# country: New Zealand}prov:wasDerivedFrom [ pr:P248 wd:Q265049 ]         ] ;
   wdt:P6 wd:Q597909 ;                %{\it\color{gray} \# (ds) head of gov.: Phil Goff}p:P6 [ a wikibase:Statement ;          ps:P6 wd:Q597909 ;                %{\it\color{gray} \# head of gov.: Phil Goff}pq:P580 "2016-10-09T00:00:00Z"8sd:dateTime        ] ;
   p:P6 [ a wikibase:Statement ;      %{\it\color{gray} \# (qualified statement)}ps:P6 wd:Q4116955 ;          pq:P580 "2010-01-01T00:00:00Z"^^xsd:dateTime ;  %{\it\color{gray} \# start time}pq:P582 "2016-10-08T00:00:00Z"8sd:dateTime ;          prov:wasDerivedFrom [ pr:P143 wd:Q328 ]         %{\it\color{gray} \# provenance}        ] .
Figure 4: Extract of the Wikidata entry for Auckland

The main limitation of uniform constraints is that they do not allow for nested neighbourhood constraints or references to other shapes. A possible alternative could be to construct a schema up to some fixed nesting depth given as parameter [16, 7] but the same nesting depth is seldom appropriate to all shapes. We propose to use schema patterns instead. They allow for a fine tuning of automatic schema construction by describing a general form for the target schema, but can also be used simply to restrict the namespaces of predicates of interest, or to give a particular role to some values such as the value of rdf:type.

We start by a motivating example based on Wikidata that we use for an informal description of schema patterns in Sect. 4.1. Then in Sec 4.2 we give the syntax of schema patterns.

4.1 Informal Definition

Fig. 4 presents an extract of the Wikidata entry for the city of Auckland333From retrieved on 2019/03/27.444restricted to the properties rdf:type, P17 and P6.. Entities in Wikidata are encoded by identifiers that start with Q, and properties by identifiers that start with P. The entry in Fig. 4 includes a statements for the property country (P17) with value New Zealand (Q664), and two statements for the property head of government (P6) with values Phil Goff (Q597909) and Len Brown (Q4116955). The most significant value of each property is given as a direct statements (ds) (prefix wdt:), while richer information is presented in a qualified wikibase:Statement in which the claim is accompanied by context or scope information (under which conditions the claim holds), as well es meta information such as provenance. Note that the structures of such statements are similar. They usually contain property statements (ps:), qualifiers (pq:) and provenance information.

In Fig. 5 is presented the constraint where the sample contains the Wikidata entries for Auckland, Monterey, Vienna and Kobe4, which is clearly too poor to represent the actual structure of the data.

<City> {
   a [ wikibase:Item ] %\ONE% ;
   wdt:P17  wd:  %\ONE% ;     p:P17  blank  %\PLUS% ;
   wdt:P6   wd:  %\OPT% ;     p:P6   blank  %\MANY% }
Figure 5: Most specific constraint for a sample of Wikidata cities

A more appropriate schema for cities in Wikidata4 is given in Fig. 6. It accounts for the possible qualifiers of the different properties.

<City> {
   a        wikibase:         %\ONE% ;
   wdt:P17  wd:               %\ONE% ;  %{\it\color{gray} \# exactly one direct country statementp:P17 @<Y_P17>   wdt:P6   wd:               %\OPT% ;  %{\it\color{gray} \# optional direct h. gov. statementp:P6 @<Y_P6><Y_P17> {
   a  [ wikibase:Statement ]  %\ONE% ;
   ps:P17  wd:                %\PLUS% }  %{\it\color{gray} \# at least one country statement}<Y_P6> a [ wikibase:Statement ] ps:P6 wd: pq:P580 xsd:dateTime   pq:P582 xsd:dateTime       %\OPT% }  %{\it\color{gray} \# optional end time%
Figure 6: Schema for Wikidata cities

A schema similar to can be automatically constructed using the schema pattern in Fig. 7 as input of the constraint construction algorithm. A schema pattern is similar to a schema but it omits cardinalities, it allows predicate filters (p:, , ps:, …) instead of predicates, it replaces value constraints by placeholders or , and it replaces some shape names by variables ().

The pattern defines one non-variable shape label <City>, therefore it will be used with one set of sample nodes, say , in order to construct a shapes schema. Denote the pattern for <City> and assume that contains the single node wd:Q37100 from Fig. 4. We start by matching all properties in with the predicate filters that appear in the , and every such property is matched with the most specific possible filter. That is p:P17 and p:P6 are matched with p: and we write , while . Now every property in yields a triple constraint, and the pattern requires that its object is @Y, a shape reference to a freshly created shape label. We can see that schema in Fig. 6 contains indeed two triple constraints p:P17 @<Y_P17> and p:P6 @<Y_P6>. The cardinalities of these triple constraints are not relevant here as they were obtained by considering a bigger sample set . In the general case, any property defines its corresponding sample composed of the -neighbours of the nodes in . This sample is used to determine the cardinality of the triple constraint on the one hand, and as a sample for the definition of shape label <Y_> on the other hand. Similarly, every property in yields a triple constraint which object constraint is a value constraint, as indicated by the placeholder __. Now regarding the pattern for , we already saw that it defines two different shapes as defined by , and each of these has its associated sample. Remark that does not contain filter , therefore some of the properties of the sample nodes might match none of the filters. These properties will not be considered. For instance, property prop:wasDerivedFrom appears in the sample nodes in Fig. 4, but not in the schema . We finally explain the triple constraint rdf:type [__] in . Its predicate holder is not a filter but a property, so it will be matched only by this same property. Its object constraint is the placeholder [__] indicating that we want to construct a constraint for the set of values. In the example this is the singleton list that contains wikibase:Statement.

<City> {      %{\it\color{gray} \# Shape $\textless$City$\textgreater$ contains}p: @Y ;   %\other%  __ }      %{\it\color{gray} \# Triple constraints with value constraints for all other properties}Y    rdf:type  [__] ; %{\it\color{gray} \# Triple constraint with list of values for rdf:type}ps: __;   pq:   __ ; }     %{\it\color{gray} \# Triple constraints with value constraints for all properties pq:}%
Figure 7: Schema pattern for Wikidata cities

As we saw, schema patterns are particularly fitted for the Wikidata dataset as it strongly relies on reification. But they are also useful for all datasets that use reification [5] or repetitive local structure. Simpler schema patterns can also be used for e.g. restraining the properties of interest.

4.2 Formal Definition

Assume a countable set of shape label variables ranging over .A constraint pattern (or pattern for short) is defined by the syntax in Fig. 8.

  (    )*
a variable in
Figure 8: Syntax of constraint patterns.

A schema pattern is a triple where:

  • is a finite set of shape labels and shape label variables;

  • with every label or variable in , associates a shape pattern that uses shape variables from only;

  • associates a set of nodes from with every label in .

A schema pattern defines a most specific uniform schema (or a largely accepted consensus schema) which definition is given in Appendix Bof the long version due to space limitations.

4.3 Patterns for Ontologies

We show here how a schema pattern can be used to encode some of the information available in an existing ontology that might be relevant for the schema construction. Consider the toy RDFSchema ontology that defines three classes :Human, :Teacher and :Subject with :Teacher subclass of :Human, and three properties :name, :teaches, :description with axioms

  :name    rdfs:domain :Human.    :description rdfs:domain :Subject.
  :teaches rdfs:domain :Teacher.  :teaches     rdfs:range  :Subject.

We can automatically retrieve the following schema pattern

  <Human>   { a [ %\hole% ] ;  :name %\hole% }
  <Teacher> { a [ %\hole% ] ;  :name %\hole% ;  :teaches %\hole% }
  <Subject> { a [ %\hole% ] ;  :description %\hole% }

with defined by the SPARQL query SELECT ?x WHERE ?x a :Human. and similarly for <Teacher> and <Subject> shapes. The shapes schema constructed with this pattern will contain only the properties of the ontology vocabulary attached to their respective domains.

5 Interactive Improvement of the Schema

We are convinced that an optimal shapes schema, i.e. a schema that encodes correctly the requirements for a particular application, cannot be obtained by a fully automatic process. Automatically constructed schemas are necessarily simple: if we allowed the choice operator or repeated properties555that is, allow two triple constraints with same predicate in the same neighbourhood constraint in uniform constraints, then a unique most specific constraint would not exist. Schema patterns (or other forms of parametrization) can bring a partial solution, but they may require user expertise and good knowledge about the data, which is often the reason why we want to build a schema at the first place: a chicken-and-egg situation.

Our solution is to let the user build the schema but within the interactive workflow described hereafter that gives access to automatic schema construction and to useful information about the data, and provides appropriate feedback.

Assume an RDF graph for which we want to build a schema. The interactive workflow maintains a schema together with associated validation target and schema pattern with .A target is given as a tuple of a SPARQL query to be executed against and sets of nodes and , to be added, resp. removed from the result of query . The schema and the targets can be modified using the following editing operations:

  • modify for shape label using these actions:

    • add or remove a or ;

    • group two or more triple constraints into a , or split a choice;

    • split a of the form in two s and having the same predicate, or regroup two such triple constraints;

    • change the cardinality or the of some triple constraints with predicate . In particular, the object constraint can be replaced by the automatically constructed or , where is the set of -neighbours of ;

  • modify for shape label . This action is triggered automatically when some triple constraint is changed and becomes of the form (with shape reference to ). Then the set of all IRI -neighbours of is added to . In the latter case, the is automatically constructed as or .

  • add a new shape label to with corresponding target and pattern , which triggers the automatic construction of or using as pattern and assigns the result to .

These operations allow to construct an arbitrarily complex SCL schema starting e.g. from an automatically constructed one.

At any time the user can visualize the result of validating against with target . Additionally, the user has access to the following information:

  • for any shape label and triple constraint that occurs in or in , and denoting :

    • the number of nodes in that have as predicate;

    • the minimal, maximal and average number of occurrences of predicate in the neighbourhood of ;

    • the lattice of uniform value constraints annotated with for every (see Sect. 3.1);

  • for any pair of predicates , the number of nodes from in which and co-occur; this is useful to detect possible s.

5.0.1 Implementation

We have already implemented several components of our method, some of which are illustrated in the video attached to the submission:

  • the algorithm for automatic construction of the most specific schema with only limited support of schema patterns tailored for Wikidata (video),

  • simple visualisation of statistics about the data,

  • enhanced visualisation of validation results that allows to navigate synchronously in the schema and in the graph to understand why a given node is valid or not w.r.t. a given constraint (video).

Currently our implementation is based on ShEx validation. In order to complete the implementation we need to: (1) complete the implementation of schema patterns; (2) add support for SHACL validation; (3) provide a nice visualisation of the information about the data; and (4) integrate the different components into a single application.

Fig. 9 shows a consolidated view of three of the already implemented components. We consider a sample with four Wikidata entries: Auckland, Monterey, Vienna and Kobe (restricted to a part of their predicates only). The top right panel contains the schema that was automatically constructed using a schema pattern similar to the one presented in Fig. 7. We changed a single cardinality in that schema that produced a validation error. In the bottom panel we see the list of validated nodes on which the error is highlighted. The top left panel shows part of the information provided to the user, i.e. the list of the properties of sample nodes and their frequencies of occurrence.

Figure 9: Screenshot of some parts of the tool

6 Conclusion and Future Work

We have presented a method that allows to define ShEx or SHACL schemas for existing datasets. The construction of simple (uniform) schemas is fully automatic and is accessible to novice users, while experts can supply their knowledge about the data using schema patterns as an expressive parametrization mechanism, and further edit the resulting schema. A prototype implementation of the method allows to extract and refine ShEx schemas for Wikidata. We are currently extending the implementation in order to integrate the still missing features: full support for schema patterns, translation to SHACL and integrated SHACL validation, a more readable representation of the statistics about the data using GUI widgets. As a future work we are planning to enhance schema patterns in order to capture richer information that comes from ontologies such as cardinalities, and also to allow to describe more complex references between shapes.


  • [1] Čebirić, Š., Goasdoué, F., Kondylakis, H., Kotzinos, D., Manolescu, I., Troullinou, G., Zneika, M.: Summarizing semantic graphs: a survey. The VLDB Journal (2018)
  • [2] van Dam, Jesse, C., Koehorst, J.J., Schaap, P.J., Martins, V.A., Suarez-Diez, M.: RDF2Graph a tool to recover, understand and validate the ontology of an RDF resource. Journal of Biomedical Semantics 6 (2015)
  • [3] De Meester, B., Heyvaert, P., Dimou, A., Verborgh, R.: Towards a uniform user interface for editing data shapes. In: 4th VOILA. vol. 2187, pp. 13–24 (2018)
  • [4] Fernández-Álvarez, D., García-González, H., Frey, J., Hellmann, S., Labra Gayo, J.E.: Inference of Latent Shape Expressions Associated to DBpedia Ontology. In: International Semantic Web Conference (2018)
  • [5] Frey, J., Müller, K., Hellmann, S., Rahm, E., Vidal, M.E.: Evaluation of Metadata Representations in RDF stores. Semantic Web (Preprint), 1–25 (2017)
  • [6] Knublauch, H., Ryman, A.: Shapes constraint language (SHACL). W3C Candidate Recommendation, W3C (July 2017),
  • [7] Labra Gayo, J.E., Fernández-Álvarez, D., García-González, H.: RDFShape: An RDF playground based on Shapes. In: Proceedings of ISWC (2018)
  • [8] Labra Gayo, J.E., García-González, H., Fernández-Álvarez, D., Prud’hommeaux, E.: Challenges in RDF Validation. In: Alor-Hernández, G., Sánchez-Cervantes, J.L., Rodríguez-González, A. (eds.) Current Trends in Semantic Web Technologies: Theory and Practice, chap. 6, pp. 121–151 (2018)
  • [9] Labra Gayo, J.E., Prud’hommeaux, E., Boneva, I., Kontokostas, D.: Validating RDF Data, vol. 7. Morgan & Claypool Publishers LLC (2017)
  • [10]

    Melo, A.: Automatic refinement of large-scale cross-domain knowledge graphs. Ph.D. thesis (2018)

  • [11] Melo, A., Paulheim, H.: Detection of relation assertion errors in knowledge graphs. In: Proceedings of the Knowledge Capture Conference. p. 22. ACM (2017)
  • [12] Potoniec, J., Jakubowski, P., Lawrynowicz, A.: Swift linked data miner: Mining OWL 2 EL class expressions directly from on-line rdf datasets. Journal of Web Semantics First Look (2017)
  • [13] Principe, R.A.A., Spahiu, B., Palmonari, M., Rula, A., De Paoli, F., Maurino, A.: ABSTAT 1.0: Compute, Manage and Share Semantic Profiles of RDF Knowledge Graphs. In: European Semantic Web Conference. pp. 170–175 (2018)
  • [14] Prud’hommeaux, E., Boneva, I., Labra Gayo, J.E., Gregg, K.: Shape Expressions Language (ShEx). W3C Shape Expressions Community Group Drat Report (2018)
  • [15] Spahiu, B., Maurino, A., Palmonari, M.: Towards Improving the Quality of Knowledge Graphs with Data-driven Ontology Patterns and SHACL. In: WOP@ISWC (2018)
  • [16] Werkmeister, L.: Schema Inference on Wikidata. Master Thesis (2018)

Appendix 0.A The Shape Constraint Language, SHACL and ShEx

We explain here how SCL is translated to SHACL and to ShEx, then we explain the small differences in semantics depending on the target language.

Translation to SHACL

SCL’s s are represented using sh:nodeKind (for , , , ), using sh:datatype for , using sh:pattern for , and using sh:in for . A yields a sh:shape that is a conjunction (sh:and) of the encodings of its s. The operator can be represented by sh:or or by sh:xone (which one to use is a parameter of the translation). is encoded using sh:property with sh:path constraint for its predicate, while its is represented by sh:node if it is a shape reference or a nested , and by the encoding of the otherwise. Cardinality is represented by sh:minInclusive and sh:maxInclusive as expected. Additionally, if two or more triple constraints in the same neighbourhood constraint have the same predicate, then all these triple constraints are encoded using sh:qualifiedValueShape, and their cardinalities using sh:qualifiedMinCount and sh:qualifiedMaxCount. Finally, SHACL shapes have associated target declarations that are not provided by the SCL schema but by its accompanying validation target. In Fig. 10 we give as example the shapes <Person> and <Date> from Sect. 2 written in SHACL.

 <Person>  a sh:NodeShape ;
     sh:property [ sh:path owl:sameAs ;   sh:nodeKind sh:IRI ;
          sh:minCount 0  ] ;
     sh:property [ sh:path foaf:name ;   sh:datatype xsd:string ;
          sh:minCount 1 ;   sh:minCount 1 ] ;
     sh:property [ sh:path foaf:familyName ;   sh:datatype xsd:string ;
          sh:minCount 1 ;   sh:minCount 1 ] ;
     sh:property [ sh:path rdf:type;   sh:hasValue  foaf:Person ;
          sh:minCount 1; sh:maxCount 1 ]  ;
     sh:xone ( [ sh:property [ sh:path bio:birth ;   sh:datatype xsd:gYear ;
                    sh:minCount 1 ;  sh:maxCount 1 ] ]
               [ sh:property [ sh:path rdgr2:dateOfBirth ;   sh:nodeKind sh:IRI ;
                    sh:minCount 1 ;   sh:maxCount 1 ; ] ] ) ;
     sh:closed false ;   sh:targetClass foaf:Person .
<Date>  a sh:NodeShape ;
     sh:property [ sh:minCount 1 ;   sh:maxCount 1 ;
          sh:path rdf:type ;   sh:hasValue time:Instant ] ;
     sh:property [ sh:minCount 1 ;   sh:maxCount 1 ;
                   sh:path rdfs:label ;   sh:datatype xsd:int ] ;
     sh:closed false;   sh:targetClass time:Instant .
Figure 10: Shape <Person> in SHACL
Translation to ShEx

The syntax of SCL is based on the compact syntax of ShEx, therefore the translation to ShEx is almost straightforward, except for that becomes EachOf also denoted in the compact syntax, and that becomes OneOf denoted . Additionally, cardinality {1;1} is omitted, cardinaity {0;*} becomes *, {1;*} becomes + and {0;1} becomes ?, while any other cardinality remains as it is. In Fig. 11 we represent the translation to ShEx of shapes <Person> and <Date> from Sect. 2.

<Person> { rdf:type [foaf:person] ;
           owl:sameAs IRI * ;
           foaf:name xsd:string ;
           foaf:familyName xsd:string ;
           ( bio:birth xsd:gYear | rdgr2:dateOfBirth @<Date> ) }
<Date>   { rdf:type [time:Instant] ; rdfs:label xsd:int }
Figure 11: Shape <Person> in ShEx

The semantics of a SCL schema can be different if it is translated to ShEx or to SHACL. The two differences come from the choice operator and from the use of different triple constraints with the same property in the same neighbourhood constraint. This is not an issue for our approach because we make the hypothesis that the user constructs a schema for one of the two languages, not for both, depending on the application she or he has in mind and on her/his production suite. The validation results in the interactive tool are computed using the translation to the chosen target schema language, whichever it is. When the desired abstract SCL schema is ready, it is exported and can be used in production.

Appendix 0.B Formal Definition of Shape Patterns

A schema pattern is defined by the syntax in Fig. 8. We additionally require that (1) no is used more than once in the same constraint pattern, and (2) every shape label variable is used exactly once in the range of .

Denote by the set of s of constraint patterns. Remark that is a subset of the set of value constraints defined in Sect. 3, and that is an upper semilattice with least upper bound . For any , denote the set of predicate filters that appear in the direct s of (that is, excluding those that appear in some nested ). Because and is a lattice, it holds that for every property either no element of matches and we write , or there is unique most precise in s.t. and we write .

For a property , denote the set of filters in that match , i.e. . For instance, if is from Fig. 7 then and .

Fix a pattern schema for the sequel. Its associated most specific schema with uniform constraints is defined below. We point out first that is not a uniform schema as it allows nested neighbourhood constraints and shape references, but likewise uniform schemas, its neighbourhood constraints satisfy do not use choice or repeated properties. So let , we explain now which are the shape labels in and which are their definitions.

For every shape label , is in and its its definition together with its sample define a . is a conjunct of s (without s). Denote by , resp. by , the set of icates, resp. of s, that occur in the s of . For instance, and for the pattern for shape in Fig. 7. Then let be the set that contains exactly the properties that apper in and all properties that appear in the neighbourhood of and match some of the filters in .

Finally, for every predicate , its associated sample is the set of -neighbors of .

Each yields a triple constraint which object constraint and cardinality constraint are defined as follows. Let be the object constranint holder for by . That is, if , then is the object constraint holder associated with in . Otherwize, is the object constraint holder associated with , the most precise predicate filter that matches .

Now, the object constraint is, depending on the form of , and denoting the set of -neighbours of :

  • If (a value constraint holder), then .

  • If (a list of values holder), then is the list that contains exactly the values in .

  • If (a nested neighbourhood constraint pattern), then .

  • If is of the form (shape reference), then we create a fresh shape label <X_q> and . We add <X_q> to and its definition .

Because the pattern is not recursive (requirement (2) above), this procedure terminates and construcs a shapes schema.

We finally point out that schema patterns might suffer of the problem of “shrinking samples”. Even if the size of for some is sufficient, its nested neighbourhood constraints are constructed using samples of -neighbours of the nodes in for the appropriate predicate . If predicate occurs only a few times in the neighbourhood of , then the corresponding sample can be very small. In our implementation we warn the user if such situation occurs, and allow her to add additional nodes to that sample without necessarily augmenting (for efficiency and readability reasons).