XML Schema (2002)

1
www.argonavis.com.br
© 2002, 2005, 2008 Helder da Rocha (helder.darocha@gmail.com)
X170

2
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
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
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
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
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
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

1
introdução
principais componentes
X170

2
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

3
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

4
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

5
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

6
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

7
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

8
Outro exemplo
●  Considere esta instância XML
<oferta(validade="2010207222">(
((((<codigo(numero="4599"(tipo="T"/>(
((((<preco>15.2</preco>(
((((<itens>14</itens>(
</oferta>(

9
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)>(

10
Um XML Schema equivalente
<?xml(version="1.0"(encoding="UTF28"?>(
<xs:schema(xmlns:xs="http://www.w3.org/2001/XMLSchema"(elementFormDefault="qualified">(
((((<xs:element(name="oferta">(
((((((((<xs:complexType>(
((((((((((((<xs:sequence>(
((((((((((((((((<xs:element(ref="codigo"/>(
((((((((((((((((<xs:element(ref="preco"/>(
((((((((((((((((<xs:element(ref="itens"/>(
((((((((((((</xs:sequence>(
((((((((((((<xs:attribute(name="validade"(use="required"(type="xs:NMTOKEN"/>(
((((((((</xs:complexType>(
((((</xs:element>(
((((<xs:element(name="codigo">(
((((((((((((<xs:attribute(name="numero"(use="required"/>(
((((((((((((<xs:attribute(name="tipo"(use="required">(
((((((((((((((((<xs:simpleType>(
((((((((((((((((((((<xs:restriction(base="xs:NMTOKEN">(
((((((((((((((((((((((((<xs:enumeration(value="T"(/>(
((((((((((((((((((((((((<xs:enumeration(value="P"(/>(
((((((((((((((((((((((((<xs:enumeration(value="U"(/>(
((((((((((((((((((((</xs:restriction>(
((((((((((((((((</xs:simpleType>(
((((((((((((</xs:attribute>(
((((</xs:element>(
((((<xs:element(name="preco"(type="xs:string"/>(
((((<xs:element(name="itens"(type="xs:string"/>(
</xs:schema>(

11
Um XML Schema melhor
<xs:schema(xmlns:xs="http://www.w3.org/2001/XMLSchema"(…(>(
((((((((((((<xs:sequence>(…(</xs:sequence>(
((((((((((((<xs:attribute(name="validade"(use="required"(type="xs:date"/>(
((((</xs:element>(
((((<xs:element(name="codigo">(…(</xs:element>(
((((<xs:element(name="preco">(
((((((((<xs:simpleType>(
((((((((((((<xs:restriction(base="xs:decimal">(
''''''''''''''''<xs:fractionDigits'value="2"'/>(
((((((((((((</xs:restriction>(
((((((((</xs:simpleType>(
((((</xs:element>(
((((<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>(
</xs:schema>(

12
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:

13
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>

14
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

15
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

16
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:complexType>...</xs:complexType>(
((((</xs:element>(
((((...(

17
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

18
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)

19
<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

20
Tipos simples nativos do XML Schema
anySimpleType(
gDay(
string(
normalizedString(
token(
language( Name( NMTOKEN(
NCName( NMTOKENS(
ID( IDREF( ENTITY(
IDREFS( ENTITIES(
decimal(
integer(nonPositiveInteger( nonNegativeInteger(
negativeInteger( positiveInteger(long(
int(
short(
byte(
unsignedLong(
unsignedInt(
unsignedShort(
unsignedByte(
boolean(
base64binary( hexbinary(
float(
double( anyURI( QName(NOTATION(
duration( gYearMonth( gYear( gMonth(dateTime( time( date(

21
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>(

22
<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>(

23
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

24
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

25
<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>(

26
<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>(

27
<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*)

28
<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*)

1
definição e composição de
esquemas
instâncias
documentação
X170

2
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”>*

3
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

4
<xs:include>
<xs:schema*xmlns:xs="http://www.w3.org/2001/XMLSchema"**
****targetNamespace="http://www.empresa.com/pontodevenda"*
****xmlns="http://www.empresa.com/pontodevenda">*
2222<xs:include2schemaLocation="ofertaTypesComplex.xsd"/>2
2222<xs:include2schemaLocation="ofertaTypesSimple.xsd"/>*
****<xs:element*name="oferta"*type="ofertaType"*/>*
****<xs:element*name="codigo"*type="codigoType"/>*
****<xs:element*name="preco"*type="precoType"/>*
****<xs:element*name="itens"*type="itensType"/>*
</xs:schema>*
<xs:complexType*name="ofertaType">*
…*
ofertaTypesComplex.xsd*
<xs:simpleType*name="precoType">*
…*
ofertaTypesSimple.xsd*

5
<xs:import>
****targetNamespace="http://www.empresa.com/pontodevenda"*
****xmlns="http://www.empresa.com/pontodevenda"*
****xmlns:pdvt="http://www.empresa.com/pontodevenda/tipos">*
****<xs:import**
*******namespace="http://www.empresa.com/pontodevenda/tipos"**
*******schemaLocation="ofertaTypesAll.xsd"/>*
****<xs:element*name="oferta"*type="pdvt:ofertaType"*/>*
****<xs:element*name="codigo"*type="pdvt:codigoType"/>*
****<xs:element*name="preco"**type="pdvt:precoType"/>*
****<xs:element*name="itens"**type="pdvt:itensType"/>*
</xs:schema>*
<xs:schema***
****targetNamespace="http://www.empresa.com/pontodevenda/tipos"*...*>*

6
<xs:import> : o outro lado
****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"*...*>*

8
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

9
Exemplos com namespace
<oferta*xmlns:xsi="http://www.w3.org/2001/XMLSchemaQinstance"*
**xsi:schemaLocation="http://www.empresa.com/pontodevenda*
**********************ofertaElementsAllImport.xsd"*
****xmlns="http://www.empresa.com/pontodevenda"**
****validade="2010Q07Q22">*
****<codigo*numero="4599"*tipo="T"/>*
****<preco>15.2</preco>*
****<itens>14</itens>*
</oferta>*
<pdv:oferta*xmlns:xsi="http://www.w3.org/2001/XMLSchemaQinstance"*
****xsi:schemaLocation="http://www.empresa.com/pontodevenda*
************************ofertaElementsAllImport.xsd"*
****xmlns:pdv="http://www.empresa.com/pontodevenda"**
****validade="2010Q07Q22">*
****<pdv:codigo*numero="4599"*tipo="T"/>*
****<pdv:preco>15.2</pdv:preco>*
****<pdv:itens>14</pdv:itens>*
</pdv:oferta>*

10
Múltiplos namespaces
●  Schemas compostos requerem a declaração de
múltiplos namespaces na instância
●  Esquema principal
●  Instância
<xs:schema**
****targetNamespace="http://cosmos.org.br"**
****xmlns:cm="http://cosmos.org.br/com"**
****xmlns:st="http://cosmos.org.br/sat"**
****xmlns="http://cosmos.org.br"**
****xmlns:xs="http://www.w3.org/2001/XMLSchema">*
<se:sistemaEstelar*xmlns:se="http://cosmos.org.br"*
***xmlns:sat="http://cosmos.org.br/sat"*
***xmlns:cmt="http://cosmos.org.br/com"*
***xmlns:xsi="http://www.w3.org/2001/XMLSchemaQinstance"**
***xsi:schemaLocation="http://cosmos.org.br*******sistema.xsd*
***********************http://cosmos.org.br/sat***satelites.xsd*
***********************http://cosmos.org.br/com***cometas.xsd">*

11
Exemplo com múltiplos namespaces
<html*xmlns:xsi="http://www.w3.org/2001/XMLSchemaQinstance"*
****xsi:schemaLocation="http://www.w3.org/1999/xhtml22xhtml.xsd*
******************http://www.empresa.com/pontodevenda2oferta.xsd"*
****xmlns="http://www.w3.org/1999/xhtml"****
****xmlns:pdv="http://www.empresa.com/pontodevenda">*
****<head>...</head>*
****<body><div*class="oferta”>*
********<pdv:oferta*validade="2010Q07Q22">*
************<pdv:codigo*numero="4599"*tipo="T"/>*
************<pdv:preco>15.2</pdv:preco>*
************<pdv:itens>14</pdv:itens>*
********</pdv:oferta>*
****</div></body>*
</html>*
<html*xmlns:xsi="http://www.w3.org/2001/XMLSchemaQinstance"*
****xsi:schemaLocation="http://www.w3.org/1999/xhtml22xhtml.xsd*
******************http://www.empresa.com/pontodevenda2oferta.xsd"*
****xmlns="http://www.w3.org/1999/xhtml"*>*
****<head>...</head><body><div*class="oferta”>*
********<oferta*validade="2010Q07Q22"*xmlns="http://www.empresa.com/pontodevenda">*
************<codigo*numero="4599"*tipo="T"/>*
************<preco>15.2</preco>*
************<itens>14</itens>*
********</oferta>*
****</div></body>*
</html>*

12
Exemplo sem namespace
<oferta*xmlns:xsi="http://www.w3.org/2001/XMLSchemaQinstance"*
****xsi:noNamespaceSchemaLocation="ofertaElementsNoNS.xsd"**
****validade="2010Q07Q22">*
****<codigo*numero="4599"*tipo="T"/>*
****<preco>15.2</preco>*
****<itens>14</itens>*
</oferta>*

13
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

14
Anotações
<xs:complexType*name="ofertaType">*
2222<xs:annotation>2
22222222<xs:documentation2xml:lang="ptFBR">2
222222222222Os2codigos2existentes2podem2ser2obtidos22
222222222222na2tabela2PROD_CODIGOS.2
22222222</xs:documentation>2
22222222<xs:appinfo>2
222222222222SELECT2CODIGOS2FROM2PROD_CODIGOS22
222222222222222222222222222WHERE2STATUS2<22;2
22222222</xs:appinfo>2
2222</xs:annotation>*
****<xs:sequence>*
********<xs:element*ref="codigo"/>*
********<xs:element*ref="preco"/>*
********<xs:element*ref="itens"/>*
****</xs:sequence>*
****<xs:attribute*name="validade"**
******************use="required"*type="xs:NMTOKEN"/>*
</xs:complexType>*

1
elementos e atributos
X170

2
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

3
<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>-

4
Exemplo <xs:element>
<xs:schema-...->-
----<xs:element-name="oferta"-type="ofertaType"-/>-
----<xs:element-name="preco">-
--------<xs:simpleType>-
------------<xs:restriction-base="xs:decimal">-
----------------<xs:fractionDigits-value="2"-/>-
------------</xs:restriction>-
--------</xs:simpleType>-
----</xs:element>-
----<xs:complexType-name="ofertaType">-
--------<xs:sequence>-
------------<xs:element-name="codigo"-type="codigoType"/>-
------------<xs:element-ref="preco"/>-
------------<xs:element-name="itens">-
----------------<xs:simpleType>-...-</xs:simpleType>-
------------</xs:element>-
--------</xs:sequence>-
----</xs:complexType>-
----<xs:complexType-name="codigoType">...</xs:complexType>-
Referência a elemento global
Declaração local com referência a
tipo global codigoType
Declaração local com definição
local de um simpleType
Declaração global com referência a
tipo global ofertaType
Declaração global com
definição local de um
simpleType

5
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>-

6
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

7
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>

8
<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>-

9
Exemplo
<xs:complexType-name="ofertaType">-
----<xs:sequence>-
--------<xs:element-name="codigo"-type="codigoType"/>-
--------<xs:element-ref="preco"/>-
--------<xs:element-name="itens">...</xs:element>-
----</xs:sequence>-
7777<xs:attribute7name="validade"77
777777777777777777use="required"7type="xs:NMTOKEN"/>-
</xs:complexType>-

10
Atributos globais
<xs:schema-xmlns:xs="http://www.w3.org/2001/XMLSchema"---
----attributeFormDefault="qualified"-
----targetNamespace="http://www.x.com/contabilidade"-
----xmlns="http://www.x.com/contabilidade">-
----<xs:attribute7name="tributado"7type="xs:boolean"7/>7
...7
<oferta-contab:tributado="true"--
--------xmlns:contab="http://www.x.org/contabilidade">-
----...--
XML Schema
Instância

11
4 maneiras de declarar atributos
<xs:attribute-name="validade"-type="xs:NMTOKEN"/>-
<xs:attribute-name="tudo"-/>-
<xs:attribute-name="tipo"-use="required">-
----<xs:simpleType>-
--------<xs:restriction-base="xs:NMTOKEN">-
------------<xs:enumeration-value="T"-/>-
------------<xs:enumeration-value="P"-/>-
------------<xs:enumeration-value="U"-/>-
--------</xs:restriction>-
----</xs:simpleType>-
</xs:attribute>--
<xs:attribute-name="validade"--
--------------type="xs:date"---
--------------default="1990I01I01"7/>-

1
tipos simples
uniões e listas
tipos nativos
X170

2
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)

3
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)

4
Exemplos com <xs:restriction> em tipos simples
<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>*
<xs:attribute*name="tipo"*use="required">*
********<xs:restriction*base="xs:NMTOKEN">*
************<xs:enumeration*value="T"*/>*
************<xs:enumeration*value="P"*/>*
************<xs:enumeration*value="U"*/>*
</xs:attribute>*
Facetas

5
Facetas
●  Limites
●  <xs:minExclusive>, <xs:minInclusive>,
●  <xs:maxExclusive>, <xs:maxInclusive>
●  Comprimento
●  <xs:length>, <xs:<minLength>, <xs:maxLength>
●  Quantidade de dígitos
●  <xs:totalDigits>, <xs:fractionDigits>
●  Conversão de espaços
●  <xs:whitespace>
●  Enumeração
●  <xs:enumeration>
●  Expressão regular
●  <xs:pattern>

6
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

7
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

8
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

9
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

10
Enumeração
●  <xs:enumeration>
●  Pode aparecer várias vezes
●  Cada <xs:enumeration> inclui um valor que pode
ser atribuído ao tipo
●  Os valores de cada <xs:enumeration> devem ser
compatíveis com o tipo base.

11
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

12
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>*

13
Uniões com memberTypes
●  Pode-se formar uniões por referência, se tipos
forem globais, com atributo memberTypes
****<xs:union*memberTypes="TamanhoNumericoType*"*/>*
********<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:union>*
</xs:simpleType>**
****<xs:union*memberTypes="TamanhoNumericoType*TamanhoLetraType"*/>*
</xs:simpleType>*

14
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

15
Exemplo de listas
<xs:simpleType*name="CoordsType">*
4444<xs:list>*
******<xs:simpleType>*
*********<xs:restriction*base="xs:integer">*
************<xs:minInclusive*value="M1024"*/>*
************<xs:maxInclusive*value="1024"*/>*
*********</xs:restriction>*
******</xs:simpleType>*
444</xs:list>*
</xs:simpleType>*

16
Tipos nativos
Veja*http://www.xml.dvint.com/
docs/SchemaDataTypesQRM2.pdf*

17
Tipos primitivos e exemplos de uso
• *xs:string:** * * * *"um*texto",*"abc"*
• *xs:boolean:* * * * *true*ou*false*
• *xs:decimal:* * * * *M12,*12.3333*
• *xs:float*e*xs:double:* *200.56,*3.12eM2*
• *xs:duration:* * * * *MP3Y9M8D2H42M55S*
• *xs:dateTime:* * * * *2010M12M06T08:30:55M03:00*
• *xs:time:* * * * * *08:30:55*
• *xs:date:* * * * * *2010M12M06*
• *xs:gYear:* * * * * *2010*
• *xs:gYearMonth:* * * *2010M12*
• *xs:gMonthDay:** * * *MM12M06*
• *xs:gMonth:** * * * *MM12*
• *xs:gDay:* * * * * *MMM06*
• *xs:hexBinary:** * * *0FB8*
• *xs:base64Binary: * * *0FB8*
• *xs:anyURI:** * * * *http://www.xyz.com*
• *xs:QName:* * * * * *pdv:preco*
• *xs:NOTATION**

1
tipos complexos
modelos de conteúdo
grupos
X170

2
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>'

3
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>)

4
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

5
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>'

6
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:sequence>'
''''''''''''<xs:element'maxOccurs="unbounded"'ref="item"/>'
!!!!!!!!</xs:sequence>'
</xs:element>'

7
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:choice'maxOccurs="unbounded"'mixed="true">'
''''''''''''<xs:element'ref="titulo"/>'
''''''''''''<xs:element'ref="codigo"/>'
''''''''''''<xs:element'ref="link"/>'
''''''''</xs:choice>'
</xs:element>'

8
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:attribute'name="horas"''
''''''''''''''''''''''type="xs:integer"/>'
</xs:element>'

9
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.

10
<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>'
''''<orbita>...</orbita>'
</sistemaEstelar>'
<sistemaEstelar'type="sistemaEstelarType">'
''''<centro>...</centro>'
</sistemaEstelar>'
inválido
válido

11
<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>'

12
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"/>'

13
4 formas de incluir atributos em tipos complexos
''''<xs:group'ref="grupoCorpos"'/>'
!!!!<xs:attribute!ref="raio"!/>'
</xs:complexType>'
''''<xs:choice>'
''''''''<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>'
<xs:complexType>'
!!!!<xs:attribute!name="horas"!type="xs:integer"/>'
</xs:complexType>'
<xs:complexType>'
''''<xs:simpleContent>'
''''''''<xs:extension'base="xs:string">'
!!!!!!!!!!!!<xs:attribute!name="tipo"!type="xs:NCName"/>'
''''''''</xs:extension>'
''''</xs:simpleContent>'
</xs:complexType>'

14
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:sequence>'
''''''''''''<xs:element'ref="titulo"/>'
''''''''''''<xs:element'ref="topicos"/>'
''''''''</xs:sequence>'
''''''''<xs:attributeGroup!ref="codDcurso"!/>!'
</xs:element>'

1
extensão
restrição
substituição
X170

2
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>

3
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

4
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

5
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

6
Exemplo de extensão com <xs:sequence>
<xs:complexType!name="ResumidoType">!
!!!!<xs:sequence>!
!!!!!!!!<xs:element!ref="titulo"/>!
!!!!!!!!<xs:element!ref="cargaDhoraria"/>!
!!!!!!!!<xs:element!ref="preDrequisito"/>!
!!!!</xs:sequence>!
</xs:complexType>!
<xs:complexType!name="CompletoType">!
!!!!<xs:extension!base="ResumidoType">!
!!!!!!!!<xs:sequence>!
!!!!!!!!!!!!<xs:element!ref="descricao"/>!
!!!!!!!!!!!!<xs:element!ref="objetivo"/>!
!!!!!!!!!!!!<xs:element!ref="topicos"/>!
!!!!!!!!</xs:sequence>!
!!!!!!!!<xs:attributeGroup!ref="cod>curso"/>!!
!!!!</xs:extension>!
</xs:complexType>!
<xs:complexType>!
!!!!<xs:sequence>!
!!!!!!!!!!!!<xs:element!ref="titulo"/>!
!!!!!!!!!!!!<xs:element!ref="cargaDhoraria"/>!
!!!!!!!!!!!!<xs:element!ref="preDrequisito"/>!
!!!!</xs:sequence>!
!!!!<xs:attributeGroup!ref="cod>curso"/>!
</xs:complexType>!
Resultado
equivalente à
extensão

7
Exemplo de extensão com <xs:choice>
<xs:complexType!name="ResumidoType">!
!!!!<xs:choice>!
!!!!</xs:choice>!
</xs:complexType>!
<xs:complexType!name="CompletoType">!
!!!!<xs:extension!base="ResumidoType">!
!!!!!!!!<xs:choice>!
!!!!!!!!</xs:choice>!
!!!!!!!!<xs:attributeGroup!ref="cod>curso"/>!!
</xs:complexType>!
<xs:complexType>!
!!!!<xs:sequence>!
!!!!!!!!!!!!<xs:element!ref="titulo"/>!
!!!!!!!!!!!!<xs:element!ref="cargaDhoraria"/>!
!!!!!!!!!!!!<xs:element!ref="preDrequisito"/>!
!!!!!!!!</xs:choice>!
!!!!!!!!</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>

8
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)

9
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:complexType>! + um atributo

10
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>!

11
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

12
Exemplo: restrição de conteúdo complexo
<xs:complexType!name="CursoResumidoType">!
!!!!<xs:complexContent>!
!!!!!!!!<xs:restriction!base="CursoCompletoType">!
!!!!!!!!!!!!<xs:sequence>!
!!!!!!!!!!!!!!!!<xs:element!ref="titulo"/>!
!!!!!!!!!!!!!!!!<xs:element!ref="carga>horaria"/>!
!!!!!!!!!!!!!!!!<xs:element!ref="pre>requisito"/>!
!!!!!!!!!!!!</xs:sequence>!
!!!!!!!!</xs:restriction>!
!!!!</xs:complexContent>!
</xs:complexType>!
<xs:complexType!name="CursoCompletoType">!
!!!!<xs:sequence>!
!!!!!!!!<xs:element!ref="descricao"/>!
!!!!!!!!<xs:element!ref="objetivo"/>!
!!!!!!!!<xs:element!ref="topicos"/>!
!!!!</xs:sequence>!
</xs:complexType>!

13
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>

14
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

15
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!

16
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!

17
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>!

18
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

1
chaves
referências cruzadas
X170

2
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

3
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>*

4
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:unique*name="codigoProdutoPedido">*
******<xs:selector*xpath="*/pedido"/>*
******<xs:field*xpath="itens/produto/@codigo"/>*
******<xs:field*xpath="@codigo"/>*
**</xs:unique>*
</xs:element>*

5
<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: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>*

XML Schema (2002)

Mais conteúdo relacionado

Mais procurados (20)

Destaque (7)

Semelhante a XML Schema (2002) (20)

Mais de Helder da Rocha (20)

Último (20)

XML Schema (2002)