W3C home > Mailing lists > Public > public-rdf-shapes@w3.org > July 2014

Re: Draft: SPIN Minimum Profile

From: Holger Knublauch <holger@topquadrant.com>
Date: Thu, 24 Jul 2014 12:33:33 +1000
Message-ID: <53D0707D.9000803@topquadrant.com>
To: "public-rdf-shapes@w3.org" <public-rdf-shapes@w3.org>
Hi Karen,

if Resource Shapes are the "language" then SPIN itself is mostly a 
"meta-language". I am not sure how this relates to the requirements 
database - at least those topics would need to be kept apart.

In terms of other specific "Shape-like" requirements, you may want to 
take a look at this SPIN library:

http://semwebquality.org/mediawiki/index.php?title=SemWebQuality.org

which includes numerous SPIN templates for common patterns.

In terms of the core SPIN templates that we have always used, there are 
just two important ones:

spl:Attribute
     - spl:predicate
     - spl:valueType
     - spl:minCount
     - spl:maxCount
     - spl:defaultValue

spl:Argument
     - spl:predicate
     - spl:valueType
     - spl:optional (false is default, meaning cardinality [1..1])
     - spl:defaultValue

Rather recently, for our EVN product, we have introduced a few more, 
which you can see if you download TBC-FE and open spl.spin.ttl, then 
look under spl:ConstraintTemplates



But I am sure this is just the start and we are not "married" to those 
particular definitions. Excerpts from the documentation (auto-generated 
using SPARQL Web Pages) is below.

HTH
Holger


    spl:Argument (spin:ConstructTemplate)

Provides metadata about an argument of a SPIN Function or Template. 
Arguments wrap a given rdf:Property (predicate) and specify its value 
type and whether the argument is optional. When used as spin:constraing, 
the body of this template will verify that a non-optional value exists 
and that it has the specified value type.


      Arguments

*rdfs:comment* (xsd:string): [Optional] a comment describing the argument
*spl:defaultValue*: [Optional] the default value for the argument
*spl:optional* (xsd:boolean): [Optional] indicates whether the argument 
is optional
*spl:predicate* (rdf:Property): the property holding the values of each 
function call
*spl:valueType* (rdfs:Class): [Optional] the value type of the argument


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?predicate .
     _:b0 rdfs:label ?label .
}
WHERE {
     {
         FILTER isIRI(?this) .
     } .
     {
         {
             {
                 FILTER ((!bound(?optional)) || (?optional = false)) .
             } .
             OPTIONAL {
                 ?this ?predicate ?value .
             } .
             FILTER (!bound(?value)) .
         } .
         BIND (CONCAT("Missing value for argument ", afn:localname(?predicate)) AS ?label) .
     }
     UNION
     {
         {
             {
                 FILTER bound(?valueType) .
             } .
             ?this ?predicate ?value .
             FILTER ((!spl:instanceOf(?value, ?valueType)) && ((?valueType != rdfs:Resource) || isLiteral(?value))) .
         } .
         BIND (CONCAT("Incorrect type of argument ", afn:localname(?predicate), " (expected: ", afn:localname(?valueType), ")") AS ?label) .
     } .
}

------------------------------------------------------------------------


    spl:Attribute (spin:ConstructTemplate)

Defines an "attribute" of a class. Attribute definitions bundle common 
modeling patterns known from object-oriented languages like UML. Each 
attribute can have min and max cardinality, a value type and a default 
value. The attribute links a class with one RDF property. This template 
should be used as spin:constraints on a class to make sure that classes 
meet the expected cardinalities and valueType constraints. If a model 
wants to use spl:defaultValue, then it should instantiate the 
spl:ConstructDefaultValues as a spin:constructor at some root class, 
such as rdfs:Resource.


      Arguments

*rdfs:comment* (xsd:string): [Optional] a comment describing the meaning 
of this attribute
*spl:defaultValue*: [Optional] the default value of the attribute
*spl:maxCount* (xsd:integer): [Optional] the maximum number of values 
permitted for the property
*spl:minCount* (xsd:integer): [Optional] the minimum number of values 
permitted for the property
*spl:predicate* (rdf:Property): the RDF property holding the attribute value
*spl:valueType* (rdfs:Class): [Optional] the type that all values of the 
property must have


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?predicate .
}
WHERE {
     {
         FILTER (bound(?minCount) && (spl:objectCount(?this, ?predicate) < ?minCount)) .
     }
     UNION
     {
         FILTER (bound(?maxCount) && (spl:objectCount(?this, ?predicate) > ?maxCount)) .
     }
     UNION
     {
         FILTER bound(?valueType) .
         ?this ?predicate ?value .
         FILTER (!spl:instanceOf(?value, ?valueType)) .
     } .
}

------------------------------------------------------------------------


    spl:ExistencePropertyPairConstraint (spl:ConstraintTemplate)


      Arguments

*arg:otherProperty* (rdf:Property): The "other" property.
*arg:property* (rdf:Property): The property being constrained.


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?property .
     _:b0 rdfs:label ?message .
}
WHERE {
     FILTER EXISTS {
         ?this ?otherProperty ?someValue .
     } .
     FILTER NOT EXISTS {
         ?this ?property ?object .
     } .
     BIND (CONCAT("Property must have a value because ", ?otherProperty, " has") AS ?message) .
}

------------------------------------------------------------------------


    spl:NonExistencePropertyPairConstraint (spl:ConstraintTemplate)


      Arguments

*arg:otherProperty* (rdf:Property): The "other" property.
*arg:property* (rdf:Property): The property being constrained.


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?property .
     _:b0 rdfs:label ?message .
}
WHERE {
     FILTER NOT EXISTS {
         ?this ?otherProperty ?someValue .
     } .
     FILTER EXISTS {
         ?this ?property ?object .
     } .
     BIND (CONCAT("Property must have no values because ", ?otherProperty, " has none") AS ?message) .
}

------------------------------------------------------------------------


    spl:ObjectCountPropertyConstraint (spl:ConstraintTemplate)

Represents a constraint that can be attached to a class to specify that 
a given property must have between min and max values.


      Arguments

*arg:maxCount* (xsd:integer): [Optional] The maximum number of values 
that the property must have.
*arg:minCount* (xsd:integer): [Optional] The minimum number of values 
that the property must have.
*arg:property* (rdf:Property): The property being constrained.


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?property .
     _:b0 rdfs:label ?message .
}
WHERE {
     BIND (spl:objectCount(?this, ?property) AS ?objectCount) .
     FILTER ((bound(?minCount) && (?objectCount < ?minCount)) || (bound(?maxCount) && (?objectCount > ?maxCount))) .
     BIND (CONCAT("Invalid number of values: ", ?objectCount) AS ?message) .
}

------------------------------------------------------------------------


    spl:RegexPropertyConstraint (spl:ConstraintTemplate)


      Arguments

*arg:pattern* (xsd:string): The regular expression to match.
*arg:property* (rdf:Property): The property being constrained.


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?property .
     _:b0 rdfs:label ?message .
}
WHERE {
     ?this ?property ?object .
     FILTER (!regex(xsd:string(?object), ?pattern)) .
     BIND (CONCAT("Value ", ?object, " must match the regular expression \"", ?pattern, "\"") AS ?message) .
}

------------------------------------------------------------------------


    spl:UntypedObjectPropertyConstraint (spl:ConstraintTemplate)

A generic SPIN template that can be used to declare a constraint that 
all values of a given property must have an rdf:type.


      Arguments

*arg:property* (rdf:Property): The property being constrained.


      Template body

CONSTRUCT {
     _:b0 a spin:ConstraintViolation .
     _:b0 spin:violationRoot ?this .
     _:b0 spin:violationPath ?property .
     _:b0 rdfs:label ?message .
}
WHERE {
     ?this ?property ?object .
     FILTER NOT EXISTS {
         ?object a ?anyType .
     } .
     BIND (CONCAT("Value ", ?object, " must have a type") AS ?message) .
}

------------------------------------------------------------------------


On 7/24/2014 2:20, Karen Coyle wrote:
> Holger, if the minimum profile could include (or link to) a list of 
> properties in the vocabulary, we could add those to the requirements 
> being gathered in the RDF AP requirements database.[1]
>
> Thanks,
> kc
> [1] http://purl.org/net/rdf-validation
>
> On 7/23/14, 5:22 AM, Holger Knublauch wrote:
>> Here is a draft for a minimum sub-set of SPIN that could serve as input
>> to this WG:
>>
>>      http://spinrdf.org/spin-min.html
>>
>> I wrote this up quickly so there may be silly mistakes, but the main
>> point I am trying to get across is that SPIN is really a very small RDF
>> vocabulary that is easy to implement and hopefully easy to agree on as
>> part of a standardization process. Of course there will be details to
>> work out, but our starting point has been in production for over six
>> years, and seems to work well.
>>
>> To illustrate my point about SPIN templates to describe Shapes, please
>> compare the example at
>>
>>      http://spinrdf.org/spin-min.html#spl
>>
>> with the original Resource Shapes proposal at
>>
>> http://open-services.net/resources/tutorials/oslc-primer/resourceshapes/
>>
>> We are really talking about very similar things here. A difference is
>> that the starting point of SPIN is SPARQL, and I believe it has a nicely
>> self-contained structure that requires only a single execution engine
>> for templates and other, more expressive, constraints.
>>
>> As a bonus, SPIN includes a simple solution for representing rules (for
>> ontology mapping and inferences) and a semantic web-friendly mechanism
>> to extend SPARQL engines with new functions. While those are not needed
>> to represent "Shapes", I believe they are low-hanging fruits that will
>> appeal to a very large technical audience and generally open up new use
>> cases for semantic web technology.
>>
>> Regards,
>> Holger
>>
>>
>>
>
Received on Thursday, 24 July 2014 02:35:02 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 17:02:39 UTC