In my experience deriving complex types by restriction is hopelessly unwieldy. For example, if the original schema allows a set of 20 currencies and you want to restrict this to just 3, then it's easy enough to define a simple type that restricts the set of currencies; but you then need a restricted version of each containing complex type, all the way up to the root node, that uses the restricted type instead of the original. Since restricting a complex type involves restating all the parts that haven't changed, you end up effectively defining a new schema rather than just defining the differences from the original one. Another approach is to define the new schema by redefining the old one using xs:redefine. That breaks horribly if you ever need to use both schemas simultaneously, e.g. if you are using data binding or if you want to do a schema-aware transformation from one to the other (the reason it breaks is that you now have several types with the same name in your system). The new xs:override in XSD 1.1 does nothing to solve this problem. Another approach is schema transformation: define the new schema as the result of applying an XSLT transformation to the old one (is this your option (1)?). This still leaves you the problem of having multiple declarations with the same name in the system (you can rename the types into a different namespace, but you can't rename the element declarations). My own preference is to restrict at the top level using assertions, but as you say, this requires XSD 1.1. If that's a problem then adding a schematron layer may work better for you. Michael Kay Saxonica
|