I think there are two main problems with complex type restriction as defined in XSD.
Firstly, you have to describe the restricted content model rather than describing the differences (which means the parts that are retained are described in more than one place.)
Secondly, what I call "deep restriction" gets incredibly convoluted: for example, if you want to restrict all monetary amounts anywhere within an abc:transaction to be in dollars, then you have to define restrictions of all the intermediate types, most of which will be identical to their base type except that some of the child elements are changed to use a restricted type.
Both these problems can be addressed by defining the restrictions using assertions. I think this is how I would normally do it in XSD 1.1. But it's not ideal: if some type has an optional element defined with minOccurs=0 maxOccurs=1, and we want to restrict this in a subtype to be absent, then the ideal syntax would in some way say "the type is the same except that maxOccurs=0" -- which is I think what Hans-Juergen is proposing. I fear though that the "tiny vocabulary" might grow rather larger than is comfortable once you start examining the use cases in detail.
You probably need to distinguish cases where the schema is designed to enable restriction, and cases where it is customized by a third party. In the first case, I think my preferred design would be to define generic parameterized types, using constructs like maxOccurs="$transaction-limit", with values for the parameters being supplied in a concrete realization of the type.
Michael Kay Saxonica
"The trouble with restriction is not knowing exactly what the differences are or why."
This is an interesting point. (And I've always avoided restriction of complex types, instinctively.)
Of course it would, in principle, be very easy to specify a restriction step explicitly, using a tiny vocabulary for specifying the removal of optional elements, other cardinality changes and whatever else is needed. Such a "restriction descriptor" might be the input (together with the original schema) for generating the restricted schema, as well as a new from-scratch schema expressing the restrictions. I wonder if there are any proven approaches to this which might be considered good practise? (And how does NIEM treat this question, where restriction of extreme generality should be extremely important?)
With kind regards, Hans-Jürgen
You are forced to use a started kitchen sink schema because is standard and therefore will make life easier.
However, most of the elements and attributes are things you dont need. And you know the full schema will blow out implementatuon and confuse testing and anyway YAGNI.
So you will make profile (Subset) of it using restriction and distribute that.
But then your schema documents may be bloated. It may be simple just have a parallel validation which just check that only wanted element names are used, using any schema language.
I.e. In allow elements a,b,c,d,e,f,g,... only chill elements a,b,c,d,e,f,g,... can be used. So the big schema states all the rules. The small one excludes unwanted canes, making it really expect. The trouble with restriction is not knowing exactly what the differences are or why. Rick
Regards Rick
|
