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