Include innerhalb eines Types

[algorithm]

Hallo allerseits!

Ich habe ein XSD Schema, und dazu mache ich "kleine" Unterschemas die ich include. Sie liegen alle im selben Namespace.

Nun habe ich im "Hauptschema" ein Element A. Dieses Element enthält die Elemente A1, A2, A3, usw... Jetzt möchte ich, dass wenn ich das Schema "B.xsd" include, dass das Element A auch das Element B beinhaltet. Wenn das Schema nicht included ist, soll es ignoriert werden.

Damit will ich bezwecken, dass Teile validiert werden können und welche Teile kann ich einfach über die Includes bestimmen. Wenn ich ein Include rausnehme, soll dieser Teil einfach nicht mehr validiert werden, also einfach ignoriert werden (ohne Validierungsfehler).

Also will ich wie ein ANY-element (mit processContents auf LAX), welches aber nicht auf Ebene Namespace, sondern auf Ebene Element funktioniert.

Kann mir jemand sagen, ob das so möglich ist?

Ich hoffe ich habe mich einigermassen verständlich ausgedrückt, ansonsten bitte nachfragen.

Danke.

[Martin Honnen]

xs: any "funktioniert" nicht auf der "Ebene Namespace", sondern kann dort verwendet werden, wo man auch ein xs: element verwenden kann.
So ich richtig verstehe, was du erreichen willst, sollte also die Verwendung von

<xs:any namespace="##targetNamespace" processContents="lax"/>

innerhalb der Definition des Inhaltes von Element A, wo B erlaubt sein soll, deinem Ziel am nächsten kommen. So sich dann im Instanzdokument ein B findet und die Schemadefinition dafür existiert, wird validiert, sonst nicht.

Ein anderer Ansatz, der es erlaubt, Schemas zusammenzusetzen und abhängig davon Typen zu erweitern, ist xs: redefine http://www.w3.org/TR/xmlschema-0/#Redefine.

[algorithm]

Das stimmt so und habe ich auch so verwendet - danke für die Antwort.

Ich kann mit dieser Lösung auch ein Element C in das Element A reinpflanzen, welches Irgendwo in meinem Schema definiert ist. A soll jedoch nur A sein oder A -> B sofern das Schema "B.xsd" included ist.

Deshalb meinte ich etwas zu suchen auf "Element-Ebene". Also etwas wie <xs:element name="B" type="B_Type" process="lax"/>. Falls B gar nicht vorhanden ist, egal, ansonsten soll B so sein wie in B_Type definiert.

Das mit dem Redefine studiere ich noch genauer, das könnte mich auf eine Spur bringen.

[algorithm]

Oder anders ausgedrückt: Wenn der Element-Typ "B_Type" vorhanden ist (weil included), dann erwarte ich an dieser Stelle (in Element "A") ein Element "B". Ansonsten, wenn B_Type nicht vorhanden ist (weil include nicht vorhanden ist), erwarte ich an dieser Stelle kein Element "B".

[Ditmar]

Mal doof gefragt, was würde gegen <xsd:choice> sprechen? Soweit ich dein Problem verstanden habe würde es auf eine einfache Art lösen.

[algorithm]

Es ist sehr gut möglich, dass ich da viel zu weit denke - ich wäre froh wenn das so einfach zu lösen ist. Das mit dem <choice> verstehe ich aber noch nicht ganz. Hier mal ein Beispiel:

Schema "Main.xsd"

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="mein-name-space"
           xmlns="mein-name-space">
    <xs:include schemaLocation="Include1.xsd"/>
    <!--xs:include schemaLocation="Include2.xsd"/-->
    <xs:complexType name="A_Type">
        <xs:sequence>
            <xs:element ref="A1"/>
            <xs:element ref="B"/>
            <xs:element ref="C"/>
        </xs:sequence>
    </xs:complexType>
    <xs:element name="A" type="A_Type"/>
    <xs:element name="A1" type="xs:string"/>
</xs:schema>

Schema "Include1.xsd"

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="mein-name-space"
    targetNamespace="mein-name-space"> 
    <xs:element name="B" type="xs:string"/>
</xs:schema>

Schema "Include2.xsd"

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="mein-name-space"
    targetNamespace="mein-name-space"> 
    <xs:element name="C" type="xs:string"/>
</xs:schema>

Wenn ich in Main.xsd das Schema "Include2.xsd" wegnehme, dann findet es das Element "C" in A_Type nicht mehr und das Schema kann selbst nicht validiert werden.

Mein Ziel ist es, wenn ich nichts Include, dass A_Type nur noch ein Element vom Typ "A1" beinhalten kann. Wenn ich Include1.xsd hinzufüge, dann kann es auch noch das Element "B" drin haben (aber nichts anderes) und wenn ich Include2.xsd hinzufüge, dann kann es auch noch ein Element C drin haben. Wenn nur Include2.xsd drin wäre (Include1.xsd aber nicht) dann dürfte A_Type nur noch A1 und C drin haben.

Ich habe das mit redefine mal ausprobiert, jedoch geht das innerhalb des Includes nicht weil sonst A_Type mehrmals vorkommt. Ich müsste das Redefine in Main.xsd machen - was ja nicht das ist, was ich brauche. Oder gibt's da eine Lösung?

[Ditmar]

Ok jetzt habe ich es verstanden aber so wie du es vor hast geht es glaube ich nicht.

Lösung mit choice wäre:
Auf die verschiedenen XSD's zu verzichen und die Typenbestimmung innherhalb einer XSD' oder einem include zu steuern

    <xs:complexType name="A_Type">
            <xs:choice>
                 <xs:element name="a1" type="A1"/>
                 <xs:element name="b" type="B"/>
                 <xs:element name="c" type="C"/>
             </xs:choice>
    </xs:complexType>

Verstehen kann das wie folgt: Im Komplexen Typ A_Type ist entweder A1, B oder C. Natürlich können diese wiederm eine beliebige Komplexität besitzen.

Lösung mit redefne:
Wahrscheinlich die Lösung die deinem Wunsch am nähsten kommt.

    
main.xsd
<xs:complexType name="A_Type">
        <xs:sequence>
            <xs:element name="A1" type="A1"/>
        </xs:sequence>
</xs:complexType>
<xs:element name="A" type="A_Type"/>
<xs:element name="A1" type="xs:string"/>

untermenge1.xsd
 <xs:redefine schemaLocation="main.xsd">
    <xs:complexType name="A_Type">
        <xs:complexContent>
            <xs:element name="B" type="B"/>       
        </xs:complexContent>
    </xs:complexType>
 </xs:redefine>

...

Mit Redefine kannst du auch die Datentypen erweitern bzw. einschrenken. Am Ende hättest du mehre XSD files die alle gültig sein sollten und auch xml Files validieren können

[algorithm]

Das mit choice ist nicht das was ich erreichen will.

Das was du mit redefine beschrieben hast, habe ich auch schon ausprobiert. Es scheint aber so, dass du nur vom "main"-Schema aus, etwas aus dem Include redefinen kannst. Du kannst "selber" aber kein include sein und etwas redefinen das dich included.

Wenn ich das Beispiel von dir ausprobiere (habe natürlich die fehlenden Elemente noch vervollständigt), dann motzt mich der XSD-Validator an, dass A_Type mehrmals vorhanden ist im selben Namespace. Ich denke das kriege ich, zu mindest nicht solange alles im selben Namespace liegt, nicht so hin wie ich mir das vorstelle.

Jedenfalls danke ich euch für eure Mühe - habe zu mindest das Tag "Redefine" neu kennengelernt!

Grüsse
A~