Epl en 12:11 16 ene 2015

2015-01-16T12:11:37Z

Página nueva

== Tipos complexos ==

Os elementos complexos conteñen outros elementos ou atributos.

=== Elementos XSD ===

==== Que é un elemento complexo? ====

Un elemento complexo é un elemento de XML que contén outros elementos e/ou atributos.

Hai catro clases de elementos complexos:
* elementos baleiros (con atributos)
* elementos que conteñen soamente outros elementos
* elementos que conteñen soamente texto (con atributos)
* elementos que conteñen tanto outros elementos como texto

NOTA: Cada un destes elementos pode conter atributos tamén.

==== Exemplos de elementos complexos ====

Un elemento de XML complexo, "produto", o cal está baleiro:
<source lang="xml">
<produto pid="1345"/>
</source>

Un elemento de XML complexo, "empregado", o cal contén só outros elementos:
<source lang="xml">
<empregado>
<nome>Marta</nome>
<apelidos>Pérez</apelidos>
</empregado>
</source>

Un elemento de XML complexo, "comida", o cal contén soamente texto:
<source lang="xml">
<comida type="postre">Xeado de vainilla</comida>
</source>

Un elemento de XML complexo, "descricion" o cal contén ambos elementos e texto:
<source lang="xml">
<descricion>
Sucedeu en <data lang="spanish">03.03.99</data> ....
</descricion>
</source>

==== Como definir un elemento complexo ====

Mira o seguinte elemento XML "empregado", que contén outros elementos:

<source lang="xml">
<empregado>
<nome>Marta</nome>
<apelidos>Pérez</apelidos>
</empregado>
</source>

Podemos definir un elemento complexo nun XML Schema de dous xeitos diferentes:

'''1.-''' O elemento "empregado" pode ser declarado directamente nomeando o elemento, así:
<source lang="xml">
<xs:element name="empregado">
<xs:complexType>
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

Se empregamos este método soamente o elemento "empregado" poderá usar este tipo complexo. Fíxate que os elementos fillos nome e apelidos están dentro do indicador '''<sequence>'''. Isto quere dicir que os elementos fillos deben aparecer na mesma orde na que foron declarados.

'''2.-''' O elemento empregado pode ter un atributo que faga referencia ó nome do tipo complexo utilizado:
<source lang="xml">
<xs:element name="empregado" type="infopersoal"/>

<xs:complexType name="infopersoal">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</source>

Si usamos este método, podemos permitir que outros elementos fagan referencia ó tipo complexo, por exemplo:
<source lang="xml">
<xs:element name="empregado" type="infopersoal"/>
<xs:element name="estudante" type="infopersoal"/>
<xs:element name="profesor" type="infopersoal"/>

<xs:complexType name="infopersoal">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</source>

Incluso podemos crear outro elemento complexo baseado no elemento complexo anterior para así engadir máis elementos, por exemplo:

<source lang="xml">
<xs:element name="empregado" type="infopersoalcompleta"/>

<xs:complexType name="infopersoal">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>

<xs:complexType name="infopersoalcompleta">
<xs:complexContent>
<xs:extension base="infopersoal">
<xs:sequence>
<xs:element name="direccion" type="xs:string"/>
<xs:element name="cidade" type="xs:string"/>
<xs:element name="pais" type="xs:string"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</source>

=== Elementos baleiros XSD ===

Un elemento baleiro XSD non pode ter contido, soamente atributos.

Exemplo de elemento XML baleiro:
<source lang="xml">
<produto prodid="1345" />
</source>

É posible declarar o elemento "produto" da seguinte maneira:
<source lang="xml">
<xs:element name="produto">
<xs:complexType>
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>
</xs:element>
</source>

Ou podemos darlle un nome ó tipo complexo e deixar que o elemento teña un atributo que faga referencia ó nome do tipo complexo (si usamos este método, diferentes elementos poderán referenciar ó mesmo tipo complexo):
<source lang="xml">
<xs:element name="produto" type="tipopoproduto"/>

<xs:complexType name="tipopoproduto">
<xs:attribute name="prodid" type="xs:positiveInteger"/>
</xs:complexType>
</source>

=== Soamente elementos XSD ===

Un tipo complexo "elements-only" contén un elemento que contén soamente outros elementos.

Por exemplo temos un elemento "persoa" que contén soamente outros elementos:
<source lang="xml">
<persoa>
<nome>Emilio</nome>
<apelidos>Martínez</apelidos>
</persoa>
</source>

Poderemos definir nun schema XML "persoa" do seguinte xeito:
<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

NOTA: O tag <sequence> indica que os elementos definidos ("nome" e "apelidos") deberán aparecer na orde indicada polo elemento "persoa".

Ou tamén poderíamos dar un nome a ese tipo complexo para poder emprega-lo noutros elementos. Por exemplo:
<source lang="xml">
<xs:element name="persoa" type="tipopersoa"/>

<xs:complexType name="tipopersoa">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</source>

=== Soamente texto XSD ===

Un elemento complexo "text-only" pode conter texto e atributos.

Este tipo contén soamente contidos sinxelos (texto e atributos). Cando empregamos '''simpleContent''' deberemos definir unha extensión ou restrición dentro do elemento, por exemplo:
<source lang="xml">
<xs:element name="algunnome">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="tipobase">
....
....
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>

Ou

<xs:element name="algunnome">
<xs:complexType>
<xs:simpleContent>
<xs:restriction base="tipobase">
....
....
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</source>

'''NOTA''': Poderemos empregar a restrición/extensión para expandir ou limitar o tipo base para o elemento.

Exemplo de elemento XML "numerozapatos" que contén soamente texto:

<source lang="xml">
<numerozapatos pais="france">35</numerozapatos >
</source>

O seguinte exemplo declara un tipo complexo "numerozapatos". O contido está definido como un integer e o elemento numerozapatos tamén contén o atributo "pais":
<source lang="xml">
<xs:element name="numerozapatos ">
<xs:complexType>
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="pais" type="xs:string" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</source>

Incluso poderíamo sdarlle ao tipo complexo un nome e deixar que "numerozapatos" teña un atributo que faga referencia a ese tipo complexo (deste xeito varios elementos poderían facer referencia ó mesmo tipo complexo):
<source lang="xml">
<xs:element name="numerozapatos" type="tipozapatos"/>

<xs:complexType name="tipozapatos">
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="pais" type="xs:string" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</source>

=== Contido misturado XSD ===

Un elemento de tipo contido misturado pode ter atributos, elementos e texto.

Exemplo de elemento XML "carta" que contén tanto texto como outros elementos:
<source lang="xml">
<carta>
Estimado/a <nome>John Smith</nome>.
O seu pedido <numpedido>1032</numpedido>
será entregado <dataentrega>2011-01-19</dataentrega>.
</carta>
</source>

O seguinte schema declara o elemento "carta":
<source lang="xml">
<xs:element name="carta">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="numpedido" type="xs:positiveInteger"/>
<xs:element name="dataentrega" type="xs:date"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

'''NOTA:''' Para permitir que poidamos introducir caracteres entre os elementos fillo, deberemos por atributo "mixed" a "true".

Tamén poderíamos darlle ó tipo complexo un nome e deixar o elemento "carta" cun atributo que faga referencia a ese tipo complexo.
<source lang="xml">
<xs:element name="carta" type="tipocarta"/>

<xs:complexType name="tipocarta" mixed="true">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="numpedido" type="xs:positiveInteger"/>
<xs:element name="dataentrega" type="xs:date"/>
</xs:sequence>
</xs:complexType>
</source>

=== Indicadores XSD ===

Podemos controlar COMO van ser empregados os elementos nos documentos, empregando os indicadores.

Hai 7 indicadores:
Indicadores de orde:
* All
* Choice
* Sequence

Indicadores de ocorrencias:
* maxOccurs
* minOccurs

Indicadores de Grupo:
* Group name
* attributeGroup name

==== Indicadores de orde ====
'''Indicador All''': O indicador "All" especifica que os elementos fillos poden aparecer en calquera orde e que cada elemento fillo debe aparecer soamente unha vez:

<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:all>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:all>
</xs:complexType>
</xs:element>
</source>

'''NOTA''': Cando empregamos o indicador <all> podemos establecer <minOccurs> a 0 ou 1 e <maxOccurs> soamente a 1.

'''Indicador Choice''': O indicador <choice> especifica que pode aparecer tanto un elemento fillo coma o outro:
<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:choice>
<xs:element name="empregado" type="empregado"/>
<xs:element name="membro" type="membro"/>
</xs:choice>
</xs:complexType>
</xs:element>
</source>

'''Indicador Sequence''': O indicador <sequence> especifica que os elementos fillo deben aparecer na orde especificada:
<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

==== Indicadores de ocorrencia ====

Os indicadores de ocorrencia úsanse para definir cantas veces pode aparecer un elemento.

'''NOTA''': Para os indicadores "Order" e "Group" (any, all, choice, sequence, group name e group reference) o valor por defecto para maxOccurs e minOccurs é 1.

'''Indicador maxOccurs''': O indicador <maxOccurs> especifica o número máximo de veces que pode aparecer un elemento:

<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:sequence>
<xs:element name="nome_completo" type="xs:string"/>
<xs:element name="alcumes" type="xs:string" maxOccurs="10"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

No exemplo anterior indícase que o elemento "alcumes" pode aparecer un mínimo de unha vez (o valor por defecto para minOccurs é 1) é un máximo de 10 veces no elemento "persoa".

'''Indicador minOccurs''': O indicador <minOccurs> especifica o número mínimo de veces que pode aparecer un elemento:
<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:sequence>
<xs:element name="nome_completo" type="xs:string"/>
<xs:element name="alcumes" type="xs:string"
maxOccurs="10" minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

O exemplo indica que o elemento <alcumes> pode aparecer un mínimo de 0 veces e un máximo de 10 veces no elemento "persoa".

'''NOTA''': Para permitir que un elemento apareza un número ilimitado de veces, use maxOccurs="unbounded".

==== Indicadores de grupo ====

Os indicadores de grupo úsanse para definir conxuntos relacionados de elementos.

'''Grupos de elementos''': Os "Element groups" defínense coa declaración:
<source lang="xml">
<xs:group name="nomedegrupo">
...
</xs:group>
</source>

Teremos que definir dentro de declaración group un elemento tipo all, choice ou sequence. O seguinte exemplo define un grupo chamado "grupopersoas", cun grupo de elementos que deben aparecer na orde exacta:
<source lang="xml">
<xs:group name="grupopersoas">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
<xs:element name="nacemento" type="xs:date"/>
</xs:sequence>
</xs:group>
</source>

Cando xa temos definido un grupo podemos referencia-lo noutra definición, por exemplo:
<source lang="xml">
<xs:group name="grupopersoas">
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
<xs:element name="nacemento" type="xs:date"/>
</xs:sequence>
</xs:group>

<xs:element name="persoa" type="infopersoa"/>

<xs:complexType name="infopersoa">
<xs:sequence>
<xs:group ref="grupopersoas"/>
<xs:element name="pais" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</source>

'''Grupos de Atributos''': Os "Attribute groups" defínense coa declaración:
<source lang="xml">
<xs:attributeGroup name="nomegrupo">
...
</xs:attributeGroup>
</source>

O seguinte exemplo define un attribute group chamado "grupoatributospersoas":
<source lang="xml">
<xs:attributeGroup name="grupoatributospersoas">
<xs:attribute name="nome" type="xs:string"/>
<xs:attribute name="apelidos" type="xs:string"/>
<xs:attribute name="nacemento" type="xs:date"/>
</xs:attributeGroup>
</source>

Unha vez que xa temos definido o grupo de atributos, podemos referencialo noutra definición como:
<source lang="xml">
<xs:attributeGroup name="grupoatributospersoas">
<xs:attribute name="nome" type="xs:string"/>
<xs:attribute name="apelidos" type="xs:string"/>
<xs:attribute name="nacemento" type="xs:date"/>
</xs:attributeGroup>

<xs:element name="persoa">
<xs:complexType>
<xs:attributeGroup ref="grupoatributospersoas"/>
</xs:complexType>
</xs:element>
</source>

=== Elemento <any> XSD ===

O elemento <any> permite extender o documento XML con elementos non especificados no Schema.

O seguinte exemplo é un fragmento dun esquema chamado "familia.xsd" que amosa a declaración para o elemento "persoa". Empregando o elemento <any> podemos extender (despois dos <apelidos>) o contido de "persoa" con calquera elemento:
<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
<xs:any minOccurs="0"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</source>

Agora queremos extender o elemento "persoa" un elemento "fillos". Neste caso poderemos facelo aínda que o autor do schema nunca declarara un elemento "fillos".

Mira o exemplo "fillos.xsd":
<source lang="xml">
<?xml version="1.0" encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.iessanclemente.net"
xmlns="http://www.iessanclemente.net"
elementFormDefault="qualified">

<xs:element name="fillos">
<xs:complexType>
<xs:sequence>
<xs:element name="nomefillo" type="xs:string"
maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>

</xs:schema>
</source>

O seguinte arquivo "familia.xml" emprega compoñentes dos dous diferentes esquemas; "familia.xsd" e "fillos.xsd":
<source lang="xml">
<?xml version="1.0" encoding="ISO-8859-1"?>

<persoas xmlns="http://www.microsoft.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:SchemaLocation="http://www.microsoft.com familia.xsd
http://www.iessanclemente.net fillos.xsd">

<persoa>
<nome> Patricia</nome>
<apelidos>Conde</apelidos>
<fillos>
<nomefillo>Lucia</nomefillo>
</fillos>
</persoa>

<persoa>
<nome>Irene</nome>
<apelidos>Sainz</apelidos>
</persoa>

</persoas>
</source>

O arquivo xml anterior é valido por que o esquema "familia.xsd" permítenos extender o elemento "persoa" con elementos opcionais despois do elemento "apelidos".

Os elementos <any> e <anyAttribute> empréganse para facer EXTENSIBLES os documentos. Permiten conter ós documentos elementos adicionais que non están declarados no Schema XML principal.

=== Elemento <anyAttribute> ===

O elemento <anyAttribute> permítenos extender o documento XML con atributos non especificados no Schema.

O seguinte exemplo é un fragmento dun Schema XML chamado "familia.xsd". Amosa a declaración do elemento <persoa>. Empregando o elemento <anyAttribute> podemos engadir calquera número de atributos ó elemento "persoa":
<source lang="xml">
<xs:element name="persoa">
<xs:complexType>
<xs:sequence>
<xs:element name="nome" type="xs:string"/>
<xs:element name="apelidos" type="xs:string"/>
</xs:sequence>
<xs:anyAttribute/>
</xs:complexType>
</xs:element>
</source>

Agora queremos extender o elemento "persoa" cun atributo "xenero".
Mira o código do schema "atributos.xsd":
<source lang="xml">
<?xml version="1.0" encoding="ISO-8859-1"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.iessanclemente.net"
xmlns="http://www.iessanclemente.net"
elementFormDefault="qualified">

<xs:attribute name="xenero">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="home|muller"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>

</xs:schema>
</source>

O seguinte arquivo XML (chamado "familiares.xsd") emprega compoñentes dos dous diferentes schemas; "familia.xsd" e "atributos.xsd":
<source lang="xml">
<?xml version="1.0" encoding="ISO-8859-1"?>

<persoas xmlns="http://www.microsoft.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:SchemaLocation="http://www.microsoft.com familia.xsd
http://www.iessanclemente.net attributos.xsd">

<persoa xenero="muller">
<nome>Raquel</nome>
<apelidos>López</apelidos>
</persoa>

<persoa xenero="home">
<nome>Martín</nome>
<apelidos>Garcia</apelidos>
</persoa>

</persoas>
</source>

O arquivo anterior é valido por que emprega o schema "familia.xsd" que nos permite engadir un atributo ó elemento "persoa".

Os elementos <any> e <anyAttribute> empréganse para facer EXTENSIBLES os documentos. Permiten conter ós documentos elementos adicionais que non están declarados no Schema XML principal.

=== Elemento Substitution XSD ===

Nos schemas XML podemos substituír un elemento por outro.

Por exemplo digamos que temos dous países diferentes: Francia e Italia. Poderíamos ter a posibilidade de deixar que o usuario escolla cando quere empregar nomes de elementos pertencentes a Francia ou a Italia no documento XML.

Para solucionar este problema, poderíamos definir un substitutionGroup no schema XML. Primeiro teríamos que declarar o elemento cabeceira e logo declarar outros elementos que poderían ser substituídos polo elemento cabeceira.

<source lang="xml">
<xs:element name="nome" type="xs:string"/>
<xs:element name="nomen" substitutionGroup="nome"/>
</source>

<source lang="xml">
<xs:element name="nome" type="xs:string"/>
<xs:element name="nomen" substitutionGroup="nome"/>

<xs:complexType name="infocomprador">
<xs:sequence>
<xs:element ref="nome"/>
</xs:sequence>
</xs:complexType>

<xs:element name="acheteur" type="infocomprador"/>
<xs:element name="acquirente" substitutionGroup="acheteur"/>
</source>

Un documento XML válido en base ó schema anterior podería ser:
<source lang="xml">
<acheteur>
<nome>Pedro Garcia</nome>
</acheteur>
</source>

ou ben:
<source lang="xml">
<acquirente>
<nomen>Pedro Garcia</nomen>
</acquirente>
</source>

==== Elemento de substitución block ====

Para evitar que outros elementos substitúan a outro elemento especificado, empregaremos o atributo "block":

<source lang="xml">
<xs:element name="nome" type="xs:string" block="substitution"/>
</source>

Mira o seguinte fragmento XML:
<source lang="xml">
<xs:element name="nome" type="xs:string"/>
<xs:element name="nomen" substitutionGroup="nome"/>

<xs:complexType name="infocomprador">
<xs:sequence>
<xs:element ref="nome"/>
</xs:sequence>
</xs:complexType>

<xs:element name="acheteur" type="infocomprador" block="substitution"/>
<xs:element name="acquirente" substitutionGroup="acheteur"/>
</source>

Un documento válido podería ser:
<source lang="xml">
<acheteur>
<nome>Pedro Garcia</nome>
</acheteur>
</source>

Pero o seguinte documento xa NON sería válido:
<source lang="xml">
<acquirente>
<nomen>Pedro Garcia</nomen>
</acquirente>
</source>

Tipos complexos - Historial de revisiones

Epl en 12:11 16 ene 2015