Elementos XSD complexos
Um elemento complexo contém outros elementos e/ou atributos.O que é um elemento complexo ?
Um elemento complexo é um elemento XML que contém outros elementos e/ou atributos.Há quatro tipos de elementos complexos:
- elementos vazios
- elementos que contém apenas outros elementos
- elementos que contém apenas texto
- elementos que contém tanto outros elementos quanto texto
Exemplos de elementos XML complexos
Um elemento XML complexo, "product", que é vazio:<product pid="1245"/>Um elemento XML complexo, "employee", que contém apenas outros elementos:
<employee> <firstname>John</firstname> <lastname>Smith</lastname> </employee>Um elemento XML complexo, "food", que contém apenas texto:
<food type="dessert">Ice cream</food>Um elemento XML complexo, "description", que contém outros elementos e texto:
<description> It happened on <date lang="norwegian">03.03.99</date> .... </description>
Como definir um elemento complexo
Observe este elemento XML complexo, "employee", que contém apenas outros elementos:<employee> <firstname>John</firstname> <lastname>Smith</lastname> </employee>Nós podemos definir um elemento complexo em um XML Schema de diferente maneiras:
1. O elemento "employee" pode ser declarado diretamente, nomeando o elemento:
<xs:element name="employee">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
<xs:sequence>
</xs:complexType>
</xs:element>
Se você usar o método descrito acima, apenas o elemento "employee" pode
usar o tipo complexo definido. Note que os elementos filhos, "firstname"
e "lastname", são envolvidos pelo indicador <sequence>. Isto
significa que os elementos filhos devem aparecer na mesma ordem da
declaração: "firstname" primeiro e "lastname" depois. Você vai aprender
sobre indicadores no capítulo Indicadores XSD;
2. O elemento "employee" pode ter um atributo tipo que faz referência ao nome do tipo complexo que deve ser usado:
<xs:element name="employee" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string/">
</xs:sequence>
</xs:complexType>
Se você usar o método descrito acima, vários elementos podem fazer referência ao mesmo tipo complexo, assim:
<xs:element name="employee" type="personinfo"/>
<xs:element name="student" type="personinfo"/>
<xs:element name="member" type="personinfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
Você também pode basear um elemento do tipo complexo em um tipo complexo existente e adicionar alguns elementos, assim:
<xs:element name="employee" type="fullpersoninfo"/>
<xs:complexType name="personinfo">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="personinfo" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="fullpersoninfo">
<xs:complexContent>
<xs:extension base="personinfo">
<xs:sequence>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
<xs:complexType>
Elementos complexos vazios
Um elemento complexo vazio pode conter atributos; mas não pode ter nenhum conteúdo entre as tags de abertura e fechamento.Defina tipos complexos para elementos vazios
Um elemento XML vazio:<product prodid="1345"/>O elemento "product" acima não tem conteúdo. Para definir um tipo sem conteúdo, nós devemos definir um tipo que permita apenas elementos em seu conteúdo, mas nós não declaramos nenhum elemento realmente, assim:
<xs:element name="product">
<xs:complexType>
<xs:complexContent>
<xs:restriction base="xs:integer">
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:element>
No exemplo acima, nós definimos um complexType tento complexContent,
i.e. apenas elementos. O elemento complexContent diz que queremos
restringir ou extender o modelo de conteúdo de um tipo complexo, e a
restrição de inteiros declara um atributo mas não cria nenhum elemento.
Entretanto, é possível declarar o elemento product de forma mais compacta, assim:
<xs:element name="product">
<xs:complexType>
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>
</xs:element>
Ou você pode dar um nome ao complexType, e fazer o elemento "product"
ter um tipo que faz referência ao nome do complexType (se você usar este
método, vários elementos podem referenciar o mesmo tipo complexo):
<xs:element name="product" type="prodtype"/>
<xs:complexType name="prodtype">
<xs:atrribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>
Tipos complexos apenas elementos
Um tipo complexo "apenas elementos" contém um elemento que contém apenas outros elementos.Defina tipos complexos apenas com elementos
Um elemento XML, "person", que contém apenas outros elementos:<person> <firstname>John</firstname> <lastname>Smith</lastname> </person>Você pode definir o elemento "person" em um esquema, assim:
<xs:element name="person">
<xs:complexType>
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Note a tag <xs:sequence>. Isto significa que os elementos
definidos ("firstname" e "lastname") devem aparecer nesta ordem dentro
do elemento "person".
Ou você pode dar um nome ao complexType, e um atributo type ao elemento "person" que faz referência a ele (se você usar este método, vários elementos podem referenciar o mesmo tipo complexo).
<xs:element name="person" type="persontype"/>
<xs:complexType name="persontype">
<xs:sequence>
<xs:element name="firstname" type="xs:string"/>
<xs:element name="lastname" type="xs:string"/>
</xs:sequence>
</xs:complexType>
Elementos complexos apenas texto
Um elemento complexo texto pode conter tanto atributos quanto texto.Defina um elemento complexo apenas texto
Este tipo contém apenas conteúdo simples (texto e atributos), assim nós adicionamos um elemento simpleContent em torno do conteúdo. Quando usar conteúdo simples, você precisa definir uma extensão OU uma restrição com o elemento simpleContent, assim:
<xs:element name="somename">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="basetype">
....
....
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
OU
<xs:element name="somename">
<xs:complexType>
<xs:simpleContent>
<xs:restriction base="basetype">
....
....
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
</xs:element>
Dica: Use o elemento extension para expandir o tipo simples base de um elemento, e o elemento restriction para limitá-lo.
Aqui está um exemplo de um elemento XML, "shoesize", que contém apenas texto:
<shoesize country="france">35</shoesize>O exemplo a seguir declara um complexType, "shoesize". O conteúdo é definido como tipo de dado integer e o elemento "shoesize" também contém um atributo chamado "country":
<xs:element name="shoesize">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:integer":
<xs:attribute name="country" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
Nós também poderíamos definir um nome para o complexType, e especificar
um atributo type ao elemento "shoesize" que faz referência ao nome do
complexType (se você usar este método, vários elementos podem
referenciar o mesmo tipo complexo):
<xs:element name="shoesize" type="shoetype"/>
<xs:complexType name="shoetype">
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="country" type="xs:string"/>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
Tipos complexos com conteúdo misto
Um elemento do tipo complexo misto pode conter atributos, elementos, e texto.Defina tipos complexos com conteúdo misto
Um elemento XML, "letter", que contém tanto outros elementos quanto texto:<letter> Dear Mr.<name>John Smith</nam> Your order <orderid>1032</orderid> wil be shipped on <shipdate>2001-07-13</shipdate>. </letter>Note o texto que aparece entre os elementos. "name", "orderid", e "shipdate" são todos filhos de "letter". O seguinte esquema declara o elemento "letter":
<xs:element name="letter">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="orderid" type="xs:positiveInteger"/>
<xs:element name="shipdate" type="xs:date"/>
</xs:sequence>
</xs:complexType>
<xs:element>
Nota: Para permitir que caracteres apareçam entre os elementos
filhos de "letter", o atributo mixed deve ser definido como "true". A
tag <xs:sequence> significa que os elementos definidos (name,
orderid e shipdate) devem parecer nesta ordem no elemento "letter".
Nós também poderíamos dar um nome ao elemento complexType, e definir o atributo type de "letter" como uma referência a ele (se você usar este método, vários elementos podem fazer referência ao mesmo complexType):
<xs:element name="letter" type="lettertype"/>
<xs:complexType name="lettertype" mixed="true">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="orderid" type="xs:positiveInteger"/>
<xs:element name="shipdate" type="xs:date"/>
</xs:sequence>
</xs:complexType>
Nenhum comentário:
Postar um comentário