SHACL Shape Validation

Also Known As

TL;DR

Explanation

SHACL (Shapes Constraint Language) is a W3C recommendation for expressing structural and value constraints over RDF data. Where RDF Schema and OWL primarily describe what can be inferred from a graph under an open-world assumption, SHACL takes a closed-world validation stance: it defines shapes - reusable bundles of constraints - and reports which nodes conform and which violate, producing a machine-readable validation report. SHACL is itself expressed in RDF, so shape graphs are stored, queried, and versioned like any other RDF resource.

The two central concepts are node shapes and property shapes. A node shape targets some set of focus nodes - by explicit class (sh:targetClass), by IRI (sh:targetNode), by being the subject or object of a predicate, or by an arbitrary SPARQL query - and asserts constraints those nodes must satisfy. A property shape sits inside a node shape via sh:property and describes what values a given predicate must have: cardinality (sh:minCount, sh:maxCount), datatype (sh:datatype), value range (sh:class, sh:nodeKind), pattern (sh:pattern), enumeration (sh:in), and logical combinators (sh:and, sh:or, sh:not, sh:xone). SHACL-SPARQL extends this with custom constraints written directly in SPARQL for cases the core vocabulary cannot express.

SHACL is what makes an RDF pipeline production-grade. Without it, a knowledge graph will silently accept malformed data: a Person with three birth dates, a Product missing a price, a foaf:knows pointing at a literal string. Validation runs at ingestion time (rejecting bad triples before they contaminate the store), in CI (verifying that a dataset conforms to a published shape), and at publish time (contract-checking data before handing it to consumers).

Common confusions: treating SHACL as a schema definition language, when it is a validation language over an existing graph; conflating it with SPARQL, which queries rather than validates; and assuming SHACL performs inference like OWL - it does not, it checks conformance. Also, SHACL's closed-world defaults surprise people used to OWL's open world: sh:minCount 1 means the triple must be materially present in the data graph, not merely inferable. Used well, SHACL turns fuzzy graph data into a contract-checked, auditable asset.

Common Misconception

Why It Matters

Common Mistakes

• Confusing SHACL with OWL and expecting it to infer new triples, when it only reports conformance and violations over the data as given.
• Omitting sh:targetClass or another target declaration, so the shape is defined but never actually applied to any focus nodes.
• Using sh:class where sh:datatype is needed (or vice versa), which either lets literals through as if they were IRIs or rejects valid literal values.
• Assuming missing triples pass validation because of RDF's open-world default; SHACL closes the world and sh:minCount 1 requires the triple to be present.
• Writing sprawling one-off shape graphs instead of composing reusable node and property shapes via sh:node and sh:property references.

Avoid When

• The data is not RDF and there is no plan to model it as a triple graph; JSON Schema or Protobuf will fit better.
• The graph is exploratory or throwaway and rigid shape contracts would slow experimentation more than they help.
• You need semantic inference of new facts rather than conformance checking; that is OWL's job, not SHACL's.
• Latency-critical hot paths cannot absorb full graph validation and simpler per-triple checks would suffice.

When To Use

• Ingesting third-party or user-contributed RDF into a knowledge graph and needing a contract that rejects malformed data.
• Publishing a linked-data dataset with a machine-readable shape so consumers can verify conformance themselves.
• Enforcing data-quality rules in CI over an evolving knowledge base as part of a governance and versioning process.
• Codifying an ontology's intended usage - cardinalities, datatypes, value ranges - beyond what OWL axioms can enforce.

Code Examples

# No validation: RDF loaded straight into the store, malformed data
# silently pollutes the knowledge graph and breaks downstream queries.
from rdflib import Graph

data = '''
@prefix ex: <http://example.org/> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

ex:alice a foaf:Person ;
    foaf:name "Alice", "Alicia", "Al" ;   # three names, no cardinality check
    foaf:age "not a number" ;              # wrong datatype
    foaf:knows "Bob" .                     # literal where IRI expected

ex:bob a foaf:Person .
    # missing foaf:name entirely - never noticed
'''

g = Graph()
g.parse(data=data, format="turtle")
print(f"Loaded {len(g)} triples")  # 'success' - but data is broken

# SHACL shapes catch all four defects before the data reaches the store.
from rdflib import Graph
from pyshacl import validate

data = '''
@prefix ex: <http://example.org/> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

ex:alice a foaf:Person ;
    foaf:name "Alice", "Alicia", "Al" ;
    foaf:age "not a number" ;
    foaf:knows "Bob" .

ex:bob a foaf:Person .
'''

shapes = '''
@prefix sh:   <http://www.w3.org/ns/shacl#> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .

foaf:PersonShape a sh:NodeShape ;
    sh:targetClass foaf:Person ;
    sh:property [
        sh:path foaf:name ;
        sh:datatype xsd:string ;
        sh:minCount 1 ;
        sh:maxCount 1 ;
    ] ;
    sh:property [
        sh:path foaf:age ;
        sh:datatype xsd:integer ;
        sh:minInclusive 0 ;
    ] ;
    sh:property [
        sh:path foaf:knows ;
        sh:nodeKind sh:IRI ;
        sh:class foaf:Person ;
    ] .
'''

conforms, report_graph, report_text = validate(
    Graph().parse(data=data, format="turtle"),
    shacl_graph=Graph().parse(data=shapes, format="turtle"),
    inference="rdfs",
)

if not conforms:
    print(report_text)  # itemised violations with focus node, path, message
    raise ValueError("RDF failed SHACL validation - rejecting ingestion")

Tags

Related Terms

References

• https://www.w3.org/TR/shacl/
• https://www.w3.org/TR/shacl-af/
• https://book.validatingrdf.com/
• https://www.w3.org/TR/shacl-use-cases/