Este documento fornece uma introdução aos principais conceitos e componentes do XML Schema. No primeiro dia, é apresentada a finalidade de um esquema XML e as diferenças em relação a DTD. Os principais elementos de um esquema são explicados, incluindo a declaração de elementos, atributos e tipos. O segundo dia é dedicado a tipos simples e complexos, assim como a derivação de tipos através de restrição e extensão. Ferramentas para edição e validação de esquemas XML também são discutidas.
2. 2
www.argonavis.com.br
Objetivos
● Este curso prático tem como finalidade
explorar o XML Schema para especificar
aplicações do XML e validar documentos XML
que serão usados pelas aplicações
● São abordados a maior parte dos recursos do
XML Schema
3. 3
www.argonavis.com.br
Programa
DIA 1
● 1 Introdução
● 2 Composição e instâncias
● 3 Declaração de elementos e atributos
DIA 2
● 4 Tipos simples, uniões e listas
● 5 Tipos complexos e grupos
● 6 Extensão, restrição, substituição
● 7 Chaves e referências cruzadas
DIA 3*
● 8 Programação com XML (opcional)
* verifique se está incluso no seu programa
4. 4
www.argonavis.com.br
Ferramentas
● É necessário ter uma ferramenta que possa ser usada
para editar XML Schema e validar instâncias
● Há várias opções
● Eclipse 3.1 e Netbeans 4 (multiplataforma, gratuitos)
● JEdit 4.2 com plugins (multiplataforma, gratuito)
● oXygen XML Editor 6 (multiplataforma, ~50USD, 30 dias)
● Um editor de texto qualquer pode ser suficiente para
editar esquemas, mas não para este curso
● É fundamental ter uma ferramenta capaz de validar XML contra
um esquema
● Não será possível saber se um exercício foi ou não resolvido se
não for possível validar
5. 5
www.argonavis.com.br
Formato do curso
● Material didático (ZIP disponibilizado na rede)
● Slides
● Apostila com material de referência (30 páginas)
● Material sobre expressões regulares
● Material extra com revisão de XML básico
● Exemplos e exercícios para resolver
● Mais de 50% deste curso é dedicado a exercícios
práticos
● É essencial que os exercícios sejam feitos em sala de
aula ao longo do curso (não deixe tudo para o final)
● Haverá uma avaliação no final com testes de múltipla
escolha (similares aos da certificação da IBM)
6. 6
www.argonavis.com.br
Módulo opcional
● O módulo 8 trata de mapeamento Java-XML
● Trata-se de um módulo prático que tem como pré-
requisito a linguagem Java
● Pacotes utilizados
● JAXB 2.0 EA2 (da distribuição Java, julho/2005)
● Apache XML Beans 2.0
● Através dos pacotes acima, pode-se construir aplicações
onde classes são mapeadas a esquemas, e objetos são
mapeados a documentos XML
● A criação de um XML causa a criação de um objeto e vice-versa
● Ferramentas usadas: Eclipse / NetBeans
7. 7
www.argonavis.com.br
Referências
● Fontes usadas na elaboração deste
treinamento
● Priscila Walmsley. Definitive XML Schema.
Prentice-Hall, 2002
● Especificações do W3C, XML Schema 1.0, níveis 0,
1 e 2. http://www.w3.org/XML/Schema
9. 2
www.argonavis.com.br
O Que é um XML Schema?
● Esquema = plano, projeto, estrutura,
diagrama, especificação
● Em XML é um documento que descreve uma
classe de documentos XML
● DTD, XML Schema, etc.
● XML Schema é documento XML usado para
especificar documentos XML
● XSDL – XML Schema Definition Language
● Namespace:
http://www.w3.org/2001/XMLSchema
10. 3
www.argonavis.com.br
Para que serve um XML Schema
● Verificar que uma instância (documento XML)
é válido em relação a um conjunto de regras
● Estrutura de elementos e atributos,
● Ordem e obrigatoriedade dos elementos,
● Tipos de dados que podem ser usados em atributos
e elementos,
● Faixas de valores válidas,
● Padrão que um texto precisa obeceder, etc.
● Documentar o sistema
● Fornecer meta-informação e defaults
● Ser um protocolo de comunicação
11. 4
www.argonavis.com.br
O que é um Esquema XML?
O esquema representa uma classe
Os documentos são instâncias
Esquema (universo de
documentos válidos)
Documentos que aderem à
especificação (válidos)
Documento
fora da
especificação
" Como definir esquemas:
" DTD - Document Type Definition
" W3C XML Schema
12. 5
www.argonavis.com.br
DTD vs. XML Schema
● Um esquema é essencial para que haja
comunicação usando XML
● Pode ser estabelecido "informalmente" (via software)
● Uso formal permite validação usando ferramentas
genéricas de manipulação de XML
● Soluções padrão do W3C
DTD XML Schema
<!ELEMENT contato
(nome, email, telefone)>
<!ATTLIST contato
codigo NMTOKEN #REQUIRED>
<xsd:schema
xmlns:xsd=".../XMLSchema">
<xsd:element name="contato">
<xsd:complexType>
<xsd:attribute name="codigo"
use="required">
• É XML, porém mais complexo
• Suporta namespaces
• Permite definição de tipos
• Simples mas não é XML
• Não suporta namespaces
• Limitado quando a tipos de dados
13. 6
www.argonavis.com.br
Exemplo de XML Schema
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="astro" type="astroType" />
<xs:element name="imagem" type="imagemType"/>
<xs:attribute name="href" type="xs:anyURI"/>
<xs:attribute name="id" type="xs:ID"/>
<xs:attribute name="nome" type="xs:string"/>
<xs:attribute name="diametrokm" type="xs:decimal"/>
<xs:complexType name="imagemType">
<xs:attribute ref="href" use="required"/>
</xs:complexType>
<xs:complexType name="astroType">
<xs:sequence>
<xs:element ref="imagem" minOccurs="0"/>
</xs:sequence>
<xs:attribute ref="id" use="required"/>
<xs:attribute ref="nome" use="required"/>
<xs:attribute ref="diametrokm"/>
</xs:complexType>
</xs:schema>
Definição de
tipos de dados
Elementos
Atributos
14. 7
www.argonavis.com.br
Um DTD equivalente
Atributos
Elementos<!ELEMENT astro (imagem*) >
<!ELEMENT imagem EMPTY >
<!ATTLIST imagem href CDATA #REQUIRED >
<!ATTLIST astro id ID #REQUIRED >
<!ATTLIST astro nome CDATA #REQUIRED >
<!ATTLIST astro diametrokm NMTOKEN #IMPLIED >
Tipos de dados simples
(somente para atributos)
Modelo de conteúdo
(tipo de dados complexo)
Atributo sempre
associado a elemento
<astro id="p5" nome="Jupiter">
<imagem href="jup31.jpg" />
<imagem href="jup32.jpg" />
</astro>
Exemplo de documento válido
em relação a este DTD
15. 8
www.argonavis.com.br
Outro exemplo
● Considere esta instância XML
<oferta(validade="2010207222">(
((((<codigo(numero="4599"(tipo="T"/>(
((((<preco>15.2</preco>(
((((<itens>14</itens>(
</oferta>(
16. 9
www.argonavis.com.br
Um DTD que valida a instância
<!ELEMENT(oferta'(codigo,preco,itens)>(
<!ATTLIST(oferta(validade(NMTOKEN(#REQUIRED>(
<!ELEMENT(codigo'EMPTY>(
<!ATTLIST(codigo(numero(CDATA(#REQUIRED(
(((((((((((((((((tipo((T(|(P(|(U)(#REQUIRED>(
<!ELEMENT(preco'(#PCDATA)>(
<!ELEMENT(itens'(NMTOKEN)>(
19. 12
www.argonavis.com.br
XML Schema
● Mais tipos, mais controle
● XML Schema oferece vários tipos de dados para
representar strings, números
● Tipos podem ser usados para validar elementos e
atributos
● Tipos novos podem ser criados a partir dos tipos
primitivos, via extensão e restrição
● Namespace e convenções
● Extensão comum usada em arquivos: *.xsd
● Prefixos mais usados para namespace: xs: ou xsd:
20. 13
www.argonavis.com.br
Principais elementos
● Elementos típicos em um esquema simples
● <schema> - elemento raiz
● <element>
● <attribute>
● <simpleType> ou <complexType>
● <simpleContent> ou <complexContent>
● <restriction> ou <extension>
● <enumeration>, <union>, <list>
● <sequence>, <choice>, <all>
21. 14
www.argonavis.com.br
Componentes declarados e definidos
● Componentes são
● Atributos
● Elementos
● Tipos
● Notações, etc.
● Componentes declarados no XML Schema são
usados nas instâncias
● Elementos, atributos, notações
● Componentes definidos no XML Schema são
usados internamente
● Tipos de dados, grupos de componentes, ids
22. 15
www.argonavis.com.br
Componentes globais e locais
● Componentes globais
● São definidos/declarados no primeiro nível do XML
Schema (filhos diretos de <xs:schema>)
● Têm nome (identificador) através do qual podem
ser usados ou reusados
● Componentes locais
● São definidos/declarados dentro do escopo de
outro componente
● Não têm nome pois não podem ser reusados
23. 16
www.argonavis.com.br
Componentes locais e globais
● O componente <xs:complexType> do esquema abaixo é
global; pode ser referenciado pelo nome ofertaType
● É referenciado na declaração de dois elementos
● O componente <xs:complexType> deste outro esquema
abaixo é local à declaração do elemento oferta e não
pode ser reusado
<xs:schema(xmlns:xs="http://www.w3.org/2001/XMLSchema">(
((((<xs:element(name="oferta"(type="ofertaType"(/>(
((((<xs:element(name="promocaoRelampago"(type="ofertaType"(/>(
((((<xs:complexType'name="ofertaType">...</xs:complexType>(
((((…(
</xs:schema>(
<xs:schema(xmlns:xs="http://www.w3.org/2001/XMLSchema">(
((((<xs:element(name="oferta">(
((((((((<xs:complexType>...</xs:complexType>(
((((</xs:element>(
((((...(
24. 17
www.argonavis.com.br
Tipos
● O tipo define a estrutura dos dados que pode
ser usada na declaração de um elemento ou
atributo.
● Pode ser local ou global
● Pode ser simples ou complexo
● Se for simples, pode ser nativo ou derivado
● Se for complexo, pode ter conteúdo simples,
conteúdo complexo, conteúdo misto ou vazio
25. 18
www.argonavis.com.br
Tipos simples e complexos
● Tipos simples
● Podem ter conteúdo de texto apenas
● Não podem conter estrutura de elementos e atributos
● Podem ser usados na declaração de atributos ou elementos
● Tipos complexos
● Podem ter elementos e atributos como conteúdo
● Podem ser usados na declaração de elementos
● Não podem ser usados na declaração de atributos
● Tipos novos podem ser derivados a partir de tipos
existentes de duas formas
● Através de restrição (válida para tipos simples e complexos)
● Através de extensão (apenas para tipos complexos)
26. 19
www.argonavis.com.br
<xs:simpleType>
● Tipo que apenas pode conter texto
● É possível criar novos tipos a partir de
derivação dos tipos existentes (globalmente
acessíveis)
<xs:simpleType(name="astroID">(
((<xs:restriction(base="xs:ID">(
((((<xs:pattern(value="cd.*"/>(
((</xs:restriction>(
</xs:simpleType>(
Expressão regular
28. 21
www.argonavis.com.br
Exemplo: derivação de um tipo simples
● Tipo base: xs:NMTOKEN
● Tipo derivado: isbn
● Faceta de comprimento:
exatamente 10 caracteres
● Faceta de formato:
descrito por expressão regular
<xs:simpleType(name="isbn">(
((<xs:restriction(base="xs:NMTOKEN">(
((((<xs:length(value="10"/>((
((((<xs:pattern(value="[029]{9}[029X]"/>(
((</xs:restriction>(
</xs:simpleType>(
29. 22
www.argonavis.com.br
<xs:complexType>
● Tipo que pode conter outros elementos ou
atributos
<xs:complexType(name="imagemType">(
((<xs:attribute(name="href"(type="xs:anyURI"/>(
</xs:complexType>(
<xs:complexType(name="astroType">(
((<xs:sequence>(
((((<xs:element(ref="imagem"(minOccurs="0"/>(
((((<xs:element(name="satelite"(type="sateliteType"((
((((((((((((((((minOccurs="0"(maxOccurs="unbounded"/>(
((</xs:sequence>(
((<xs:attribute(name="id"(type="astroID"(use="required"/>(
((<xs:attribute(name="nome"(type="xs:token"(/>(
((<xs:attribute(name="diametrokm"(type="xs:decimal"/>(
</xs:complexType>(
30. 23
www.argonavis.com.br
O que representam os tipos
● Tipos simples representam tipos de dados
básicos como texto, números, tokens, booleanos
● Fazem parte do namespace do XML Schema
(requerem prefixo associado ao identificador do
namespace), por exemplo: xs:int, xs:string
● Tipos complexos representam estruturas do
documento como entidades, atributos, etc.
● Podem fazer parte do namespace default do próprio
documento (e não necessitar de prefixo) se definidos
localmente
31. 24
www.argonavis.com.br
Fundamentos: Modelos de conteúdo
● Definem a estrutura de tipos complexos
● Modelos de conteúdo podem ser simples ou
complexos
● São simples quando elemento é vazio ou
quando contém apenas texto
● Modelo de conteúdo simples pode conter atributos
● São complexos quando elemento contém
outros elementos
● Elementos podem ser definidos localmente
● Elementos globais podem ser reutilizados
32. 25
www.argonavis.com.br
<xs:simpleContent>
● Modelo de conteúdo simples
● Determina o tipo dos dados contido em um
elemento que pode possuir atributos
<xs:complexType(name="imagemType">(
((<xs:simpleContent>(
((((<xs:restriction(base="xs:string">(
((((((<xs:attribute(name="href"(
((((((((((((((((((((type="xs:anyURI"/>(
((((</xs:restriction>(
((</xs:simpleContent>(
</xs:complexType>(
33. 26
www.argonavis.com.br
<xs:complexContent>
● Modelo de conteúdo complexo
● Determina a organização dos elementos filho
(se uma lista de opções, uma seqüência, etc.
<xs:complexType(name="estrelaType">(
(((<xs:complexContent>(
((((((<xs:extension(base="astroType">(
(((((((((<xs:sequence>(
((((((((((((<xs:element(name="satelite"(
((((((((((((((((((((((((type="sateliteType"(
((((((((((((((((((((((((minOccurs="0"(
((((((((((((((((((((((((maxOccurs="unbounded"/>(
(((((((((</xs:sequence>(
(((((((((<xs:attribute(name="cor"(type="xs:token"/>(
((((((</xs:extension>(
(((</xs:complexContent>(
</xs:complexType>(
34. 27
www.argonavis.com.br
<xs:sequence>
● Conteúdo de tipos complexos
● Equivalente ao conteúdo (a, b, c) em DTD
<xs:element(name="sistemaEstelar">(
((<xs:complexType>(
((((<xs:sequence>(
((((((<xs:element(name="centro"(type="centroType"/>(
((((((<xs:element(name="orbita"(type="orbitaType"(
((((((((((((((((((minOccurs="0"(maxOccurs="unbounded"/>(
((((((<xs:element(ref="cometa"(minOccurs="0"((
((((((((((((((((((maxOccurs="unbounded"/>(
((((</xs:sequence>(
((</xs:complexType>(
</xs:element>(
Equivalente, em DTD, a (centro, orbita*, cometa*)
35. 28
www.argonavis.com.br
<xs:choice>
● Conteúdo de tipos complexos
● Equivalente ao conteúdo (a | b | c) no DTD
<xs:complexType(name="orbitaType">(
((<xs:choice>(
((((<xs:element(name="estrela"(type="estrelaType"/>(
((((<xs:element(name="planeta"(type="sateliteType"/>(
((((<xs:element(name="asteroide"(type="sateliteType"((
((((((((((((((((minOccurs="0"(maxOccurs="unbounded"/>(
((</xs:choice>(
((<xs:attribute(name="raioMedUA"(type="xs:decimal"/>(
</xs:complexType>(
Equivalente a (estrela | planeta | asteroide*)
37. 2
www.argonavis.com.br
Cabeçalho e namespace
● Todas as declarações do XML Schema estão contidas em
um elemento <xs:schema> que deve definir:
● Um atributo xmlns, declarando o namespace do XML Schema,
geralmente associando-o a um prefixo (xs ou xsd).
● Um atributo targetNamespace*, contendo uma URI que
identifique o namespace da linguagem-alvo que o XML Schema
está descrevendo
● Um segundo atributo xmlns*, declarando o namespace da
linguagem-alvo, possivelmente associando-o a um prefixo.
<xs:schema*xmlns:xs="http://www.w3.org/2001/XMLSchema"*
****targetNamespace="http://www.empresa.com/pontodevenda"**
****xmlns="http://www.empresa.com/pontodevenda">*
Se a linguagem não usar namespaces:
<xs:schema*xmlns:xs="http://www.w3.org/2001/XMLSchema”>*
38. 3
www.argonavis.com.br
Composição de esquemas
● <xs:include> insere componentes de esquema do mesmo
namespace localizados em outros arquivos
● Atributo schemaLocation informa a URI onde se encontra o
arquivo que será incluído
*<xs:include2schemaLocation="esquema.xsd"/>
● <xs:import> importa componentes de namespaces
diferentes
● Atributo namespace é obrigatório
● Atributo schemaLocation é opcional
*<xs:import2namespace="http://ns.com"*schemaLocation="esquema.xsd"/>
● <xs:redefine> permite redefinir componentes
41. 6
www.argonavis.com.br
<xs:import> : o outro lado
<xs:schema*xmlns:xs="http://www.w3.org/2001/XMLSchema"**
****targetNamespace="http://www.empresa.com/pontodevenda/tipos"*
****xmlns="http://www.empresa.com/pontodevenda/tipos"*
****xmlns:pdv="http://www.empresa.com/pontodevenda">*
****<xs:import*namespace="http://www.empresa.com/pontodevenda"**
********schemaLocation="ofertaElementsAll.xsd"></xs:import>*
****<xs:complexType*name="ofertaType">*
********<xs:sequence>*
************<xs:element*ref="pdv:codigo"/>*
************<xs:element*ref="pdv:preco"/>*
************<xs:element*ref="pdv:itens"/>*
********</xs:sequence>*
********<xs:attribute*name="validade"*use="required"*type="xs:NMTOKEN"/>*
****</xs:complexType>*
****<xs:complexType*name="codigoType">...</xs:complexType>*
****<xs:simpleType*name="precoType">...</xs:simpleType>*
****<xs:simpleType*name="itemType">...</xs:simpleType>*
</xs:schema>*
<xs:schema***
****targetNamespace="http://www.empresa.com/pontodevenda"*...*>*
42. 7
www.argonavis.com.br
Defaults
● <xs:schema> contém atributos que definem
defaults para tipos e elementos.
● attributeFormDefault="qualified|unqualified"
● elementFormDefault="qualified|unqualified"
● blockDefault="#all|substitution|extension|
restriction"
● finalDefault="#all|extension|restriction|list|union"
● Determinam comportamento default em
declarações e definição de componentes
● (Mais sobre isto adiante)
43. 8
www.argonavis.com.br
Instâncias associadas a um XML Schema
● Uma instância pode ser formalmente vinculada
a uma instância através de atributos globais
● Namespace XML Schema Instance:
http://www.w3.org/2001/XMLSchema-instance
● Este namespace deve ser atribuído a prefixo
para que se possa usar seus 4 atributos:
● schemaLocation – para vincular um ou mais XML
Schemas à instância
● noNamespaceSchemaLocation – para vincular a um
XML Schemas que não usa namespace
● nil e type – usados em elementos e atributos
48. 13
www.argonavis.com.br
Anotações
● <xs:annotation>
● Mecanismo de documentação e extensão do XML
Schema
● Pode ser usado em qualquer elemento do XML
Schema
● Dois sub-elementos: <xs:documentation> e
<xs:appinfo>
● <xs:documentation>
● Para documentação que será lida por humanos
● <xs:appinfo>
● Ponto de extensão para informações de
processamento que serão lidas por máquina
51. 2
www.argonavis.com.br
Elementos
● Declarados através de <xs:element>
● Declaração (global ou local) deve ter atributo
name
● Pode conter elemento <xs:simpleType> ou
<xs:complexType>, ou atributo type com
referência para tipo nativo ou global
● Referência a um elemento global através de
atributo ref, em definições de tipos complexos
52. 3
www.argonavis.com.br
<xs:element>
● Define um elemento
● Deve estar associado a um tipo de dados
ou
<xs:complexType-name="cometaType">-
--<xs:attribute-name="id"-type="xs:ID"-use="required"/>-
--<xs:attribute-name="nome"-type="xs:string"-use="required"/>-
--<xs:attribute-name="planetas"-type="xs:IDREFS"/>-
</xs:complexType>-
<xs:element-name="cometa"-type="cometaType"-/>-
<xs:element-name="cometa">-
--<xs:complexType>-
----<xs:attribute-name="id"-type="xs:ID"-use="required"/>-
----<xs:attribute-name="nome"-type="xs:string"-use="required"/>-
----<xs:attribute-name="planetas"-type="xs:IDREFS"/>-
--</xs:complexType>-
</xs:element>-
54. 5
www.argonavis.com.br
4 maneiras de associar um tipo a um elemento
<xs:element-name="endereco"-type="xsd:string"-/>-
<xs:element-name="tudo"-/>-
<xs:element-name="cpf"-type="CpfType"-/>-
<xs:element-name="itens">-
----<xs:simpleType>-
--------<xs:restriction-base="xs:integer">-
------------<xs:minInclusive-value="1"/>-
------------<xs:maxInclusive-value="20"/>-
--------</xs:restriction>-
----</xs:simpleType>-
</xs:element>-
55. 6
www.argonavis.com.br
Valores default para elementos
● Valores default podem ser atribuídos caso o
elemento esteja ausente ou vazio
<xs:element-ref="preco"-default="0.00"/>-
<xs:element-name="itens"-type="itensType"-default="10">-
<oferta-validade="2010J10J10">-
----<codigo-numero="4599"-tipo="T"-/>-
----<itens-/>-
</oferta>-
<oferta-validade="2010J10J10">-
----<codigo-numero="4599"-tipo="T"-/>-
7777<preco>0.00</preco>-
----<itens>10</itens>-
</oferta>-
Documento original
Documento após o
processamento
56. 7
www.argonavis.com.br
Atributos
● Geralmente declarados em tipos complexos
● Localmente, no contexto do tipo que será
associado a um elemento
● Podem ser declarados globalmente
● Para esquemas que fornecem atributos globais
(geralmente prefixados)
● Dentro de tipos complexos, são declarados
após o conteúdo
● Declaram-se atributos com <xs:attribute>
57. 8
www.argonavis.com.br
<xs:attribute>
● Define um atributo
● Pode estar embutido na definição de um tipo
ou globalmente acessível (para reutilização)
<xs:attribute-name="raio"-type="xs:decimal"/>-
<xs:complexType-name="sateliteType">-
--<xs:complexContent>-
----<xs:extension-base="astroType">-
-----<xs:attribute-ref="raio"-use="required"/>-
-----<xs:attribute-name="anoDesc"-type="xs:int"/>-
----</xs:extension>-
--</xs:complexContent>-
</xs:complexType>-
62. 2
www.argonavis.com.br
Tipos simples
● Elementos ou atributos podem ter conteúdo
definido como tipo simples
● Tipos simples podem ser:
● valores atômicos
● listas
● uniões
● São definidos com o elemento
<xs:simpleType>
● São tipos complexos
● Tipos que contém outros elementos
● Tipos que contém atributos (mesmo que vazios)
63. 3
www.argonavis.com.br
Tipos base e derivação por restrição
● Todo tipo simples é uma derivação por
restrição de outro tipo simples, que é
chamado de tipo base.
● Não é possível estender tipos simples
● A restrição é feita com <xs:restriction>
● Pode ser sobre tipos primitivos ou nativos
● Pode ser sobre tipos criados no próprio esquema ou
importados
● Restrição reduz o tamanho do tipo usando
facetas (limites, comprimentos, etc)
66. 6
www.argonavis.com.br
Facetas de limites numéricos
● Usada em tipos numéricos
● Pode-se usar um e no máximo dois elementos, um
mínimo, e um máximo
● <xs:minExclusive value="valor">
● Limite inferior é maior que valor
● <xs:minInclusive value="valor">
● Limite inferior é maior ou igual a valor
● <xs:maxExclusive value="valor">
● Limite superior é menor que valor
● <xs:maxInclusive value="valor">
● Limite superior é menor ou igual a valor
67. 7
www.argonavis.com.br
Facetas de comprimento
● Usado em strings
● Deve ser um número positivo
● <xs:length>
● Comprimento exato
● <xs:minLength>
● Comprimento mínimo
● <xs:maxLength>
● Comprimento máximo
68. 8
www.argonavis.com.br
Facetas de quantidade de dígitos
● Usado em números
● <xs:totalDigits>
● Dígitos totais
● <xs:fractionDigits>
● Dígitos depois do ponto decimal
● Deve ser menor ou igual a totalDigits
69. 9
www.argonavis.com.br
Facetas de política de conversão de espaços
● Define a política de tratamento de espaços
● <xs:whitespace>
● O atributo value pode ter os valores
● preserve – preserva os espaços em branco, novas
lihas, tabulações, etc.
● replace – substitui as novas-linhas e tabulações por
um espaço, e preserva os outros espações
● collapse – substitui múltiplos espaços por um
espaço, e elimina os espaços antes e depois
71. 11
www.argonavis.com.br
Expressão regular
● <xs:pattern>
● Permite que se passe, no atributo value, uma
expressão regular que irá filtrar e restringir o
tipo base
● Exemplo
● <xs:pattern value="((d+s*){3})*” />
● Veja mais detalhes no módulo sobre
expressões regulares
72. 12
www.argonavis.com.br
Uniões
● Combinam vários tipos em um
● <xs:union>
<xs:simpleType*name="TamanhoType">*
4444<xs:union>*
********<xs:simpleType>*
************<xs:restriction*base="xs:integer">*
****************<xs:minInclusive*value="1"></xs:minInclusive>*
****************<xs:maxInclusive*value="16"></xs:maxInclusive>*
************</xs:restriction>*
********</xs:simpleType>*
********<xs:simpleType>*
************<xs:restriction*base="xs:token"*
****************<xs:enumeration*value="P"></xs:enumeration>*
****************<xs:enumeration*value="M"></xs:enumeration>*
****************<xs:enumeration*value="G"></xs:enumeration>*
****************<xs:enumeration*value="XG"></xs:enumeration>*
************</xs:restriction>*
********</xs:simpleType>*
4444</xs:union>*
</xs:simpleType>*
73. 13
www.argonavis.com.br
Uniões com memberTypes
● Pode-se formar uniões por referência, se tipos
forem globais, com atributo memberTypes
<xs:simpleType*name="TamanhoType">*
****<xs:union*memberTypes="TamanhoNumericoType*"*/>*
****<xs:simpleType>*
********<xs:restriction*base="xs:token"*
************<xs:enumeration*value="P"></xs:enumeration>*
************<xs:enumeration*value="M"></xs:enumeration>*
************<xs:enumeration*value="G"></xs:enumeration>*
************<xs:enumeration*value="XG"></xs:enumeration>*
********</xs:restriction>*
****</xs:simpleType>*
****</xs:union>*
</xs:simpleType>**
<xs:simpleType*name="TamanhoType">*
****<xs:union*memberTypes="TamanhoNumericoType*TamanhoLetraType"*/>*
</xs:simpleType>*
74. 14
www.argonavis.com.br
Listas
● Listas são valores atômicos separados por
espaços
<polygon*coords="100*0*250*100*0*250*150*50*0*50"*/>*
<time*tamanhos="M*G*XG*P*M*G*G*XG*XG*G*G*G*M*M*G"*/>*
● <xs:list>
● Cria-se uma lista com
● valores de um tipo simples local, ou
● referencia um tipo global usando o atributo
itemType
79. 2
www.argonavis.com.br
O que são tipos complexos
● No exemplo acima possuem tipos complexos os elementos:
● <curso>, <titulo>, <carga-horaria>, <pre-requisito> e <topicos>
● E possuem tipos simples os elementos:
● <titulo> e <item>
<curso'grupo="xml"'assunto="1"'subgrupo="0"'fragmento="0">'
''''<titulo>XML:'uma'introdução'prática</titulo>'
''''<cargaBhoraria'horas="24"/>'
''''<preBrequisito'tipo="obrigatorio">Conhecimento'elementar'de'
alguma'linguagem'de'markup'como'HTML</preBrequisito>'
''''<topicos>'
''''''''<item>Introdução'a'XML</item>'
''''''''<item>Como'escrever'documentos'XML</item>'
''''''''<item>Estrutura'de'uma'página'XML</item>'
''''''''<item>Como'especificar'uma'linguagem'usando'DTD</item>'
''''''''<item>XML'Namespaces</item>'
''''</topicos>'
</curso>'
80. 3
www.argonavis.com.br
Como construir
● Um tipo complexo pode ser construído de três
formas:
● A partir de conteúdo simples (elemento
<xs:simpleContent>)
● Através da definição de um grupo de elementos
(<xs:all>, <xs:group>, <xs:choice>,
<xs:sequence>)
● Através da extensão de outro tipo complexo
(<xs:complexContent>)
81. 4
www.argonavis.com.br
Conteúdos
● Um tipo complexo pode conter quatro tipos
diferentes de conteúdo
● Conteúdo simples
● Conteúdo de elementos
● Conteúdo misto
● Conteúdo vazio
82. 5
www.argonavis.com.br
Conteúdo simples
● Permite apenas texto
● A sintaxe para incluir atributos requer declarar
uma <xs:extension> para o conteúdo simples,
dentro do qual se declara o <xs:attribute>
<preBrequisito'tipo="obrigatorio">Conhecimento'elem...</item>'
<xs:element'name="preBrequisito">'
''''<xs:complexType>'
!!!!!!!!<xs:simpleContent>'
''''''''''''<xs:extension'base="xs:string">'
'''''''''''''''<xs:attribute'name="tipo"'type="xs:NCName"/>'
''''''''''''</xs:extension>'
!!!!!!!!</xs:simpleContent>'
''''</xs:complexType>'
</xs:element>'
83. 6
www.argonavis.com.br
Conteúdo de elementos
● Só aceita elementos
● Qualquer texto precisa estar dentro de um sub-
elemento.
<topicos>'
''''<item>Introdução'a'XML</item>'
''''<item>Como'escrever'documentos'XML</item>'
''''<item>Estrutura'de'uma'página'XML</item>'
''''<item>Como'especificar'uma'linguagem'usando'DTD</item>'
''''<item>XML'Namespaces</item>'
</topicos>'
<xs:element'name="topicos">'
''''<xs:complexType>'
!!!!!!!!<xs:sequence>'
''''''''''''<xs:element'maxOccurs="unbounded"'ref="item"/>'
!!!!!!!!</xs:sequence>'
''''</xs:complexType>'
</xs:element>'
84. 7
www.argonavis.com.br
Conteúdo misto
● Usa o atributo mixed="true" ao definir o tipo
complexo
<descricao>O'curso'<codigo/>:<titulo/>'proporciona'uma'
introdução...'veja'as'referências'<link'href="#ref1">[1]
</link>'e'...</descricao>'
<xs:element'name="descricao">'
''''<xs:complexType>'
''''''''<xs:choice'maxOccurs="unbounded"'mixed="true">'
''''''''''''<xs:element'ref="titulo"/>'
''''''''''''<xs:element'ref="codigo"/>'
''''''''''''<xs:element'ref="link"/>'
''''''''</xs:choice>'
''''</xs:complexType>'
</xs:element>'
85. 8
www.argonavis.com.br
Conteúdo vazio
● Nenhum conteúdo
● É implicitamente definido ao não declarar nenhum
conteúdo no tipo (exceto atributos)
<cargaBhoraria'horas="24"/>'
<xs:element'name="cargaBhoraria">'
''''<xs:complexType>'
''''''''<xs:attribute'name="horas"''
''''''''''''''''''''''type="xs:integer"/>'
''''</xs:complexType>'
</xs:element>'
86. 9
www.argonavis.com.br
Modelos de conteúdo para tipos complexos
● Para definir conteúdo formado por elementos,
é preciso usar um modelo de conteúdo.
● Há três tipos, cada um definido por um
elemento filho de <xs:complexType>:
● <xs:sequence>
● <xs:choice>
● <xs:all>
● Não é possível declarar elementos
diretamente abaixo de <xs:complexType>
● É preciso usar os elementos acima.
87. 10
www.argonavis.com.br
<xs:sequence>
● Um <xs:sequence> é usado para indicar a
ordem em que os elementos devem ser usados.
<xs:complexType'name="sistemaEstelarType">'
!!!!<xs:sequence>'
''''''''<xs:element'name="centro"'type="centroType"/>'
''''''''<xs:element'name="orbita"'type="orbitaType"''
''''''''''''minOccurs="0"'maxOccurs="unbounded"/>'
''''''''<xs:element'ref="cm:cometa"''
''''''''''''minOccurs="0"'maxOccurs="unbounded"/>'
!!!!</xs:sequence>'
</xs:complexType>'
<sistemaEstelar'type="sistemaEstelarType">'
''''<centro>...</centro>'
''''<cm:cometa>...</cm:cometa>'
''''<cm:cometa>...</cm:cometa>'
''''<orbita>...</orbita>'
''''<cm:cometa>...</cm:cometa>'
</sistemaEstelar>'
<sistemaEstelar'type="sistemaEstelarType">'
''''<centro>...</centro>'
''''<cm:cometa>...</cm:cometa>'
''''<cm:cometa>...</cm:cometa>'
</sistemaEstelar>'
inválido
válido
88. 11
www.argonavis.com.br
<xs:choice>
● Um <xs:choice> é usado para escolher um, dentre
vários elementos
● pode ser usado para permitir a inclusão de elementos em
qualquer ordem, se o atributo maxOccurs for "unbounded”
● Blocos <xs:choice> e <xs:sequence> podem ser
aninhados um dentro do outro para permitir modelos de
conteúdo mais complexos
<xs:complexType'name="orbitaType">'
!!!!<xs:choice!maxOccurs="unbounded">'
''''''''<xs:element'name="estrela"'type="estrelaType"/>'
''''''''<xs:element'name="planeta"'type="st:sateliteType"/>'
''''''''<xs:element'name="asteroide"'type="st:sateliteType"/>'
!!!!</xs:choice>'
''''<xs:attribute'name="raioMedUA"'type="xs:decimal"/>'
</xs:complexType>'
89. 12
www.argonavis.com.br
Grupos: <xs:group>
● Grupos podem ser definidos globalmente no
primeiro nível através do elemento <xs:group>
● deve ter um nome e um conteúdo <xs:choice>,
<xs:sequence>, ou <xs:all>
● Promove o reuso!
<xs:schema'...>'
!!!!<xs:group!name="grupoCorpos">'
''''''''<xs:choice'maxOccurs="unbounded">'
''''''''''''<xs:element'name="estrela"'type="estrelaType"/>'
''''''''''''<xs:element'name="planeta"'type="st:sateliteType"/>'
''''''''''''<xs:element'name="asteroide"'type="st:sateliteType"/>'
''''''''</xs:choice>'
'''!</xs:group>'
''''…'
''''<xs:complexType'name="orbitaType">'
!!!!!!!!<xs:group!ref="grupoCorpos"!/>'
''''''''<xs:attribute'name="raioMedUA"'type="xs:decimal"/>'
''''</xs:complexType>'
91. 14
www.argonavis.com.br
Grupos de atributos
● <xs:attributeGroup>
● declarado globalmente cria um grupo de atributos
que podem ser incluidos nos elementos
<xs:attributeGroup'name="codBcurso">'
''''<xs:attribute'name="assunto"'use="required"'type="xs:integer"/>'
''''<xs:attribute'name="fragmento"'use="required"'type="xs:integer"/>'
''''<xs:attribute'name="grupo"'use="required"'type="xs:NCName"/>'
''''<xs:attribute'name="subgrupo"'use="required"'type="xs:integer"/>'
</xs:attributeGroup>'
<xs:element'name="curso">'
''''<xs:complexType>'
''''''''<xs:sequence>'
''''''''''''<xs:element'ref="titulo"/>'
''''''''''''<xs:element'ref="topicos"/>'
''''''''</xs:sequence>'
''''''''<xs:attributeGroup!ref="codDcurso"!/>!'
''''</xs:complexType>'
</xs:element>'
93. 2
www.argonavis.com.br
Derivação de tipos complexos
● Pode ser feita de duas formas
● Extensão <xs:extension>
● Restrição <xs:restriction>
● Elementos são incluídos dentro de um
<xs:simpleContent> ou <xs:complexContent>
94. 3
www.argonavis.com.br
Extensão de tipos complexos
● No modelo de conteúdo simples
● Extensão para acrescentar atributos
● No modelo de conteúdo complexo
● Extensão para acrescentar atributos
● Extensão para acrescentar elementos
95. 4
www.argonavis.com.br
Extensão em conteúdo simples
● Para inclusão de um atributo
● Exemplo de uso
!<xsd:complexType!name="LarguraType">!
!!!!!!!!<xsd:simpleContent>!
!!!!!!!!!!!!<xsd:extension!base="xsd:integer">!
!!!!!!!!!!!!!!!!<xsd:attribute!name="unidade"!!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!type="UnidadesType"!/>!
!!!!!!!!!!!!</xsd:extension>!!
!!!!!!!!</xsd:simpleContent>!
!!!!</xsd:complexType>!
!!!!<xsd:element!ref="LarguraType"!/>!
<largura!unidade="cm">123</largura>!
Conteúdo simples não é afetado
96. 5
www.argonavis.com.br
Extensão em conteúdo complexo
● Podem adicionar elementos no final do modelo de
conteúdo do tipo base
● O tipo resultante combina os elementos existentes seguidos
pelos novos como em um <xs:sequence>
● É possível acrescentar novos atributos
● Não é possível redefinir, alterar ou remover atributos existentes
● A extensão de grupos <xs:choice> não resulta em um
grupo <xs:choice>
● O efeito é o da criação de um grupo <xs:sequence> contendo os
dois grupos <xs:choice>, o anterior seguido pelo novo
● Resultado: elementos incluídos no tipo estendido só podem
aparecer depois dos elementos originais
98. 7
www.argonavis.com.br
Exemplo de extensão com <xs:choice>
<xs:complexType!name="ResumidoType">!
!!!!<xs:choice>!
!!!!!!!!<xs:element!ref="titulo"/>!
!!!!!!!!<xs:element!ref="cargaDhoraria"/>!
!!!!!!!!<xs:element!ref="preDrequisito"/>!
!!!!</xs:choice>!
</xs:complexType>!
<xs:complexType!name="CompletoType">!
!!!!<xs:extension!base="ResumidoType">!
!!!!!!!!<xs:choice>!
!!!!!!!!!!!!<xs:element!ref="descricao"/>!
!!!!!!!!!!!!<xs:element!ref="objetivo"/>!
!!!!!!!!!!!!<xs:element!ref="topicos"/>!
!!!!!!!!</xs:choice>!
!!!!!!!!<xs:attributeGroup!ref="cod>curso"/>!!
!!!!</xs:extension>!
</xs:complexType>!
<xs:complexType>!
!!!!<xs:sequence>!
!!!!!!!!<xs:choice>!
!!!!!!!!!!!!<xs:element!ref="titulo"/>!
!!!!!!!!!!!!<xs:element!ref="cargaDhoraria"/>!
!!!!!!!!!!!!<xs:element!ref="preDrequisito"/>!
!!!!!!!!</xs:choice>!
!!!!!!!!<xs:choice>!
!!!!!!!!!!!!<xs:element!ref="descricao"/>!
!!!!!!!!!!!!<xs:element!ref="objetivo"/>!
!!!!!!!!!!!!<xs:element!ref="topicos"/>!
!!!!!!!!</xs:choice>!
!!!!</xs:sequence>!
!!!!<xs:attributeGroup!ref="cod>curso"/>!
</xs:complexType>!
Em elementos do tipo CompletoType
nenhuma ocorrência de <carga-horaria>
pode vir depois de <descricao>
99. 8
www.argonavis.com.br
Extensão de conteúdo misto e vazio
● A extensão de tipos com conteúdo misto força
o tipo derivado a também permitir conteúdo
misto
● É necessário declarar o atributo mixed="true" no
tipo derivado
● Um elemento de conteúdo vazio pode ser
estendido para
● Acrescentar atributos
● Acrescentar elementos (e, portanto, deixar de ter
conteúdo vazio)
100. 9
www.argonavis.com.br
Extensão de um tipo vazio
<xs:complexType!name="CargaHorariaType>!
!!!!<xs:attribute!name="horas"!type="xs:integer"/>!
</xs:complexType>!
<xs:complexType!name="CargaHorariaComMinutosEFusoHorarioType>!
!!!!<xs:extension!base="CargaHorariaType">!
!!!!!!<xs:sequence>!
!!!!!!!!<xs:element!ref="gmt"!maxOccurs="1">!
!!!!!!!!!!!!<xs:simpleType>!
!!!!!!!!!!!!!!!!<xs:restriction!base="xs:integer">!
!!!!!!!!!!!!!!!!!!!!<xs:maxInclusive>12</xs:maxInclusive>!
!!!!!!!!!!!!!!!!!!!!<xs:minInclusive>>12</xs:minInclusive>!
!!!!!!!!!!!!!!!!!!!!<xs:restriction>!
!!!!!!!!!!!!</xs:simpleType>!
!!!!!!!!</xs:element>!
!!!!!!</xs:sequence>!
!!!!!!<xs:attribute!name="minutos"!type="xs:integer"/>!
!!!!</xs:extension>!
</xs:complexType>! + um atributo
101. 10
www.argonavis.com.br
Restrição de tipos complexos
● Pode ser realizada através de
● Remoção ou restrição de atributos (escopo, valores permitidos)
● Redução de modelos de conteúdo complexos (eliminação de
elementos-filho)
● Redução de modelos de conteúdo simples (restrição de tipo de
dados)
● Exemplo: tornando um atributo positivo e obrigatório
<xs:complexType!name="CargaHorariaTypeObrigatoria">!
!!!!<xs:simpleContent>!
!!!!!!!!<xsd:restriction!base="CargaHorariaType">!
!!!!!!!!!!!!<xsd:attribute!name="horas"!!
!!!!!!!!!!!!!!!!type="xsd:positiveInteger"!use="required"!/>!
!!!!!!!!</xsd:restriction>!
!!!!</xs:simpleContent>!
</xs:complexType>!
102. 11
www.argonavis.com.br
Restrição de conteúdo complexo
● Requer a repetição de todo o modelo de
conteúdo que se deseja manter
● Elementos que não se repetirem no tipo derivado
serão eliminados
● Instâncias do tipo derivado também precisam
ser válidas em relação ao tipo base
● Restrições formalizadas no novo tipo devem ser
possíveis no tipo antigo
● Restrições não podem ampliar faixas de valores
definidas no tipo base: pode apenas mantê-las
inalteradas ou torná-las mais restritivas
104. 13
www.argonavis.com.br
Grupos de substituição
● Fundamentam-se na derivação de tipos para criar uma
hierarquia de elementos
● Similar a linguagens orientadas a objeto
● Suporta polimorfismo!
● Permite declarar novos elementos como substitutos de
esquemas e namespaces
● Herda-se o modelo de conteúdo, que pode ser alterado
● Exemplo
● Tipo base: <produto>
● Tipos de produto: <publicacao>, <roupa>, <veiculo> podem ser
usados quando o esquema pede um <produto>
● Tipos de <publicacao>: <livro>, <revista>, <jornal> podem ser
usados no lugar de <publicacao> ou de <produto>
105. 14
www.argonavis.com.br
Como usar grupos de substituição
● Raiz da hierarquia
● Qualquer elemento (ou tipo) global
● Elemento (ou tipo) base
● Filhos da hierarquia
● Referem-se à raiz através do atributo
substitutionGroup
● Compatibilidade
● Tipo de membros de um grupo de substituição
precisam ter tipos iguais ou derivados da base
106. 15
www.argonavis.com.br
Exemplo de grupos de substituição: tipos
● Declaração normal de uma hierarquia de tipos
<xs:complexType!name="ProdutoType">!
!!!!<xs:sequence>!
!!!!!!!!<xs:element!ref="preco"/>!
!!!!!!!!<xs:element!ref="codigo"/>!
!!!!</xs:sequence>!
</xs:complexType>!
<xs:complexType!name="PublicacaoType">!
!!!!<xs:complexContent>!
!!!!!!!!<xs:extension!base="ProdutoType">!
!!!!!!!!!!!!<xs:sequence>!
!!!!!!!!!!!!!!!!<xs:element!name="autores"!type="AutoresType"/>!
!!!!!!!!!!!!!!!!<xs:element!name="formato"!type="FormatoPubType"!/>!
!!!!!!!!!!!!!!!!<xs:element!name="titulo"!type="xs:string"/>!
!!!!!!!!!!!!</xs:sequence>!
!!!!!!!!</xs:extension>!
!!!!</xs:complexContent>!
</xs:complexType>!
PublicacaoType!
ProdutoType!
107. 16
www.argonavis.com.br
PublicacaoType!
ProdutoType!
ProdutoType! "dvdDType"!
Exemplos de grupos de substituição: elementos
<xs:element!name="dvd"!substitutionGroup="produto">!
!<xs:complexType>!
!!<xs:complexContent>!
!!!<xs:extension!base="ProdutoType">!
!!!!<xs:sequence>!
!!!!!<xs:element!!name="formato"!!
! ! ! !!! !type="FormatoDVDType"!/>!
!!!!</xs:sequence>!
!!!</xs:extension>!
!!</xs:complexContent>!
!</xs:complexType>!
</xs:element>!
<xs:element!name="produto"!!!!type="ProdutoType"/>!
<xs:element!name="publicacao"!type="PublicacaoType"!
!!!!!!!!!!!!!!!!!!!!!!!!!!!substitutionGroup="produto"/>!
<xs:element!name="caderno"!substitutionGroup="produto"/>!
produto!
caderno!publicacao! dvd!
108. 17
www.argonavis.com.br
Uso de grupos de substituição
!<produtos>!
!!!!!!!!<produto>!
!!!!!!!!!!!!<codigo>123</codigo>!
!!!!!!!!!!!!<preco>10.00</preco>!
!!!!!!!!</produto>!
!!!!!!!!<publicacao>!
!!!!!!!!!!!!<codigo>912</codigo>!
!!!!!!!!!!!!<preco>31.00</preco>!
!!!!!!!!!!!!<titulo>A!Origem!das!Especies</titulo>!
!!!!!!!!!!!!<autores><autor>Charles!Darwin</autor></autores>!
!!!!!!!!!!!!<formato!encadernacao="capaDdura"!dimensoes="16.3!12.5!2.8"!/>!
!!!!!!!!</publicacao>!
!!!!!!!!<dvd>!
!!!!!!!!!!!!<codigo>778</codigo>!
!!!!!!!!!!!!<preco>19.90</preco>!
!!!!!!!!!!!!<formato!area="0"!/>!
!!!!!!!!</dvd>!
!!!!!!!!<caderno>!
!!!!!!!!!!!!<codigo>834</codigo>!
!!!!!!!!!!!!<preco>15.00</preco>!
!!!!!!!!</caderno>!
</produtos>!
109. 18
www.argonavis.com.br
Elementos e tipos abstratos e finais
● O controle de acesso em grupos de substituição
pode ser declarado no tipo base ou elemento
● final="valor"
● Define o tipo ou elemento como final para diferentes
tipos de derivação
● #all – impede qualquer tipo de derivação
● abstract="true"
● declara que um elemento é cabeça de um grupo de
substituição mas não pode ser usado diretamente
● Elementos na instância só podem ser usados se forem
de componentes derivados do grupo de substituição
111. 2
www.argonavis.com.br
Identificadores
● Componentes que podem ser identificados por
chaves primárias ou identificadores unívocos
● Referenciáveis dentro ou fora do esquema ou
instância
● <xs:unique>, <xs:key> e <xs:keyref>
● Vale para elementos ou atributos
● Muito mais abrangentes que ID e IDREF (DTD)
● Identificador é aplicado em contexto localizado
através de XPath
● Pode ter um ou mais campos que compõem o
elemento ou chave unívoca
112. 3
www.argonavis.com.br
Identificador unívoco simples
● O elemento <xs:unique> define um elemento
que tem conteúdo que não se repete
● considerando os outros elementos definidos no
mesmo contexto
<xs:element*name="pedido"*type="PedidoType">*
****<xs:unique*name="codigoProduto">*
********<xs:selector*xpath="*/produto"/>*
********<xs:field*xpath="@codigo"/>*
****</xs:unique>*
</xs:element>*
113. 4
www.argonavis.com.br
Identificador unívoco composto
● É possível também definir como unívoco um
elemento com base nos valores de mais de um
campo (elemento ou atributo)
<xs:element*name="pedido"*type="PedidoType">*
**<xs:unique*name="codigoProdutoPedido">*
******<xs:selector*xpath="*/pedido"/>*
******<xs:field*xpath="itens/produto/@codigo"/>*
******<xs:field*xpath="@codigo"/>*
**</xs:unique>*
</xs:element>*
114. 5
www.argonavis.com.br
<xs:key> e <xs:keyref>
● Chaves permitem que se realize um mapeamento
entre um campo unívoco e uma referência
● Com um par <xs:key> e <xs:reyref> pode-se
estabelecer ligações entre referências e elementos
● Chaves são definidas usando XPath
<xs:element*name="pedido"*type="PedidoType">*
****<xs:keyref*name="codProdutoRef"*refer="codProduto">*
********<xs:selector*xpath="itens/*"/>*
********<xs:field*xpath="@codigo"/>*
****</xs:keyref>*
****<xs:key*name="codProduto">*
********<xs:selector*xpath=".//produto"/>*
********<xs:field*xpath="codigo"/>*
****</xs:key>*
</xs:element>*