P. 1
sistemas distribuidos

sistemas distribuidos

|Views: 312|Likes:
Published by claudiocbamt

More info:

Published by: claudiocbamt on Mar 05, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

03/08/2011

pdf

text

original

Sections

  • O que você já precisa saber
  • O que é um XML Schema?
  • XML Schemas são sucessores das DTDs
  • XML Schema é uma Recomendação do W3C
  • XML Schema tem suporte a tipos de dados
  • XML Schemas usa sintaxe XML
  • Comunicação segura de dados com XML Schemas
  • XML Schemas são extensíveis
  • Bem formado não é o bastante
  • Um documento XML simples
  • Um DTD simples
  • Um XML Schema simples
  • Uma referência para um DTD
  • Uma referência a um XML Schema
  • O elemento <schema>
  • Referenciando um Schema em um documento XML
  • O que é um elemento simples
  • Como definir um elemento simples
  • Tipos de dados XML Schema comuns
  • Declare valores padrão e fixos para elementos simples
  • O que é um atributo?
  • Como definir um atributo
  • Tipos de dados comuns do XML Schema
  • Declare valores padrão e fixo para atributos
  • Criando atributos opcionais e obrigatórios
  • Restrições de conteúdo
  • Restrições em valores
  • Restrições em séries de valores
  • Outras restrições em séries de valores
  • Restrições em caracteres vazios
  • Restrições de comprimento
  • Restrições para tipos de dados
  • O que é um elemento complexo ?
  • Exemplos de elementos XML complexos
  • Como definir um elemento complexo
  • Defina tipos complexos para elementos vazios
  • Defina tipos complexos apenas com elementos
  • Defina um elemento complexo apenas texto
  • Defina tipos complexos com conteúdo misto
  • Indicadores
  • Indicadores de ordem
  • Indicadores de ocorrência
  • Indicadores de grupo
  • O elemento <any>
  • Bloqueando substituição de elementos
  • Utilizando substitutionGroup
  • O que são elementos globais?
  • Um documento XML
  • Crie um XML Schema
  • Divida o schema
  • Usando tipos nomeados
  • Tipo de dado string
  • Tipo de dado normalizedString
  • Tipo de dado token
  • Tipos de dados string
  • Restrições em tipos de dados string
  • Tipo de dado date
  • Tipo de dado time
  • Tipo de dado dateTime
  • Tipo de dado duration
  • Restrições em tipos de dados date
  • Tipo de dado decimal
  • Tipo de dado integer
  • Restrições em tipos de dados numéricos
  • Tipo de dado boolean
  • Tipos de dados binários
  • Tipo de dado anyURI
  • Restrições em tipos de dados variados
  • As Palavras Mais Comuns da Lingua Inglesa

Introdução ao XML Schema

Tutorial XML-Schema
Colaboração: Maurício M. Maia Data de Publicação: 26 de Março de 2005 Este documento é uma tradução do tutorial do W3Schools, disponível em http://www.w3schools.com/schema/default.asp XML Schema é uma alternativa ao DTD. Neste tutorial, você vai aprender o que é um XML Schema, como ele substitui o DTD, e como usá-lo em suas aplicações.

Introdução ao XML Schema
XML Schema é uma alternativa ao DTD baseada em XML. Um esquema XML descreve a estrutura de um documento XML. A linguagem XML Schema também é chamada de XML Schema Definition (XSD).

O que você já precisa saber
Antes de estudar a Linguagem XML Schema, você deve ter um entendimento básico de XML e Namespaces XML. Também é válido um entendimento básico de DTD. Se você deseja estudar estes assuntos primeiro, visite o tutorial XML e o tutorial DTD.

O que é um XML Schema?
O propósito de um XML Schema é definir os blocos de construção permitidos em um documento XML, como um DTD. Um XML Schema: • define • define • define • define • define • define elementos que podem aparecer em um documento atributos que podem aparecer em um documento que elementos são elementos filhos a ordem dos elementos filhos o número de elementos filhos se um elemento é vazio ou pode incluir texto

1

XML Schemas - Por que?

• define tipos de dados para elementos e atributos • define valores padrão e fixos para elementos e atributos

XML Schemas são sucessores das DTDs
Nós acreditamos que logo XML Schemas vão ser usados na maioria das aplicações Web no lugar de DTDs. Aqui estão algumas razões: • XML • XML • XML • XML • XML Schemas Schemas Schemas Schemas Schemas são extensíveis para adições futuras são mais ricos e úteis que DTDs são escritos em XML suportam tipos de dados suportam namespaces

XML Schema é uma Recomendação do W3C
XML Schema foi originalmente proposto pela Microsoft, mas se tornou um recomendação oficial do W3C em Maio de 2001. A especificação está estável e foi revisada pelos membros do W3C. Para uma visão geral das atividades e status do W3C, visite o tutorial W3C

XML Schemas - Por que?
Há muitas razões para XML Schema ser melhor que DTD.

XML Schema tem suporte a tipos de dados
Uma das grandes vantagens de XML Schemas é o suporte a tipos de dados: •É •É •É •É •É •É mais mais mais mais mais mais fácil fácil fácil fácil fácil fácil descrever conteúdo de documentos permissíveis validar os dados trabalhar com dados de um banco de dados definir restrições aos dados definir padrões/formatos de dados converter dados entre diferentes tipos

XML Schemas usa sintaxe XML
Outra grande força do XML Schema é ser escrito em XML. Por isso:

2

XML Schemas usa sintaxe XML

• Você • Você • Você • Você • Você

não tem que aprender outra linguagem pode usar seu editor XML para editar seus arquivos XML Schema pode usar seu parser XML para verificar seus arquivos XML Schema pode manipular seu XML Schema com XML DOM pode usar seu XML Schema com XSLT

Comunicação segura de dados com XML Schemas
Quando um dado é enviado de um ponto para outro é essencial que as duas parte tem a mesma expectativa sobre o conteúdo. Com XML Schemas, o remetente pode descrever o dado de forma que o receptor vá entender. Uma data como "03-11-2004" vai, em alguns países, ser interpretada como 3 de Novembro e em outros com 11 de Março, mas um elemento XML com um tipo de dado como esse:
<date type="date">2004-03-11</date>

assegura um entendimento mútuo do conteúdo porque o o tipo de dado XML requer o formato YYYY-MM-DD.

XML Schemas são extensíveis
XML Schemas são extensíveis, assim como XML, porque eles são escritos em XML. Com uma definição extensível você pode: • Reutilizar seu Schema em outros Schemas • Criar seus próprios tipos de dados derivados dos tipos padrões • Referenciar múltiplos esquemas em um mesmo documento

Bem formado não é o bastante
Um documento XML bem formado é um documento que atende às regras de sintaxe XML: • deve começar com um declaração XML • deve ter um elemento raiz único • todas tags abertas precisam ser fechadas • tags XML são sensíveis à caixa alta/baixa

3

XSD How To

• todo elemento deve ser fechado • todo elemento tem que ser propriamente aninhado • todos valores de atributos precisam estar entre aspas • entidades XML devem ser usadas para caracteres especiais Mesmo se os documentos são bem formados eles podem conter erros, e estes erros podem ter conseqüências sérias. Imagine essa situação: você compra 5 tonners de impressoras laser, ao invés de 5 impressoras laser. Com XML Schemas, a maioria destes erros podem ser detectados pelo seu software de validação.

XSD How To
Documentos XML podem referenciar um DTD ou um XML Schema.

Um documento XML simples
Veja este documento XML chamado "note.xml":
<?xml version="1.0"> <note> <to>Tove</to> <from>Jani</from> <heading>Reminder<heading> <body>Don't forget me this weekend!</body> </note>

Um DTD simples
Este é um arquivo DTD chamado "note.dtd" que define os elementos do documento XML acima ("note.xml"):
<!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT <!ELEMENT note (to, from, heading, body)> to (#PCDATA)> from (#PCDATA)> heading (#PCDATA)> body (#PCDATA)>

A linha 1 define que o elemento note possui 4 elementos: "to, from, heading, body". Linhas 2 a 5 o elemento to como sendo do tipo "#PCDATA", o elemento from como "#PCDATA", e assim por diante...

4

Um XML Schema simples

Um XML Schema simples
Este é um arquivo XML Schema chamado "note.xsd" que define os elementos do documento XML acima ("note.xml"):
?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3schools.com" xmlns="http://www.w3schools.com" elementFormDefault="qualified"> <xs:element name="note"> <xs:complexType> <xs:sequence> <xs:element name="to" type="xs:string"/> <xs:element name="from" type="xs:string"/> <xs:element name="heading" type="xs:string"/> <xs:element name="body" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>

O elemento note é dito um tipo complexo porque contém outros elementos. Os outros elementos são ditos tipos simples porque não contém outros elementos. Você vai aprender mais sobre tipos simples e complexo nos próximos capítulos.

Uma referência para um DTD
Este documento XML tem uma referência para um DTD:
<?xml version="1.0"?> <!DOCTYPE note SYSTEM "http://www.w3schools.com/dtd/note.dtd"> <note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note>

5

.O elemento <schema> Uma referência a um XML Schema Este documento contém uma referência a um XML Schema: <?xml version="1.com" xmlns="http://www.O elemento <schema> O elemento <schema> é o elemento raiz de todo XML Schema! O elemento <schema> O elemento <schema> é o elemento raiz de todo XML Schema: <?xml version="1.0"?> <xs:schema> .xsd"> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note> XSD .. </xs:schema> O elemento <schema> pode conter alguns atributos.0"?> <xs:schema xmlns:xs="http://www..0"?> <note xmlns="http://www.com" xmlns:xsi="http://www.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.w3.com note.w3.w3schools.XSD ..w3schools.w3schools. Uma declaração de Schema geralmente parece com isto: <?xml version="1.org/2001/XMLSchema" targetNamespace="http://www.com" elementFormDefault="qualified"> 6 .w3schools. .

boolean.. .. element.w3.w3.. heading.com" .w3.w3schools. body) vêm do namespace "http://www. Referenciando um Schema em um documento XML Este documento XML tem uma referência para um XML Schema: <?xml version="1.w3schools. complexType.org/2001/XMLSchema" indica que os elementos e tipos de dados usados no esquema (schema. sequence. from.) vêm do namespace "http://www.com" indica que os elementos definidos por este esquema (note. etc. </xs:schema> O seguinte fragmento: <xs:schema xmlns:xs="http://www. Este fragmento: elementFormDefault="qualified"> indica que todo elemento usado por uma instância de documento XML que foi declarado neste esquema deve ser qualificado pelo namespace.org/2001/XMLSchema"..org/2001/XMLSchema" devem ser prefixados com xs: !! Este fragmento: targetNamespace="http://www.com". Ele também especifica que os elementos e tipos de dados que vêm de "http://www.0"?> 7 . string.w3schools. Este fragmento: xmlns="http://www. to.com" indica que o namespace padrão é "http://www.O elemento <schema> .w3schools.

date. Ele não pode conter outros elementos ou atributos.Elementos XSD Simples <note xmlns="http://www.com".w3schools.w3schools. Um elemento simples é um elemento XML que contém apenas texto. Ele não pode conter outros elementos ou atributos.com" especifica a declaração de namespace padrão. O segundo é a localização do esquema XML para se usado pelo namespace: xsi:schemaLocation="http://www.w3schools. Uma vez que você tem uma instância XML Schema do namespace disponível: xmlns:xsi="http://www. Entretanto.com" xmlns:xsi="http://www.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www. string.xsd"> Elementos XSD Simples XML Schemas define os elementos de um arquivo XML. Este atributo tem dois valores.w3. 8 . Esta declaração diz ao validador de esquema que os elementos usados neste documento XML são declarados no namespace "http://www. O texto pode ser de diferentes tipos.w3schools.xsd"> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note> Este fragmento: xmlns="http://www. a restrição "apenas texto" é pouco clara.org/2001/XMLSchema-instance" você pode usar o atributo schemaLocation. O que é um elemento simples Um elemento simples é um elemento XML que contém apenas texto. etc. O primeiro é o namespace usado.w3schools.com note. Pode ser um dos tipos inclusos na definição de XML Schema (boolean.w3.com note.).

Aqui está uma lista dos mais comuns: • xs:string • xs:decimal • xs:integer • xs:boolean • xs:date • xs:time Declare valores padrão e fixos para elementos simples Elementos simples podem ter um conjunto de valores padrão OU um fixos. Aqui está alguns elementos XML: <lastname>Refsnes</lastname> <age>34</age> <dateborn>1968-03-27</dateborn> E aqui as definições correspondentes: <xs:element name="lastname" type"xs:string"/> <xs:element name="age" type="xs:integer"/> <xs:element name="dateborn" type="xs:date"/> Tipos de dados XML Schema comuns XML Schema tem vários tipos de dados próprios. Um valor padrão é automaticamente atribuído ao elemento quando nenhum outro valor é especificado.O que é um elemento simples ou um tipo personalizado que você mesmo pode definir. No exemplo seguinte. Como definir um elemento simples A sintaxe para definir um elemento simples é: <xs:element name="xxx" type="yyy"/> onde xxx é o nome do elemento e yyy é o tipo de dado do elemento. o valor padrão é "red": 9 .

o valor fixo é "red": <xs:element name="color" type="xs:string" fixed="red"/> Atributos XSD Todos atributos são declarados como tipos simples. Mas atributos são declarados como tipos simples. ele é considerado do tipo complexo. Isso significa que um elemento com atributos sempre tem uma definição do tipo complexo. Se um elemento tem atributos. Você não pode especificar outro valor. Apenas elementos complexos tem atributos! O que é um atributo? Elementos simples não podem ter atributos. Aqui está uma lista dos mais comuns: 10 . No exemplo a seguir. Aqui está um elemento XML com um atributo: <lastname lang="EN>Smith</lastname> E aqui a definição correspondente do atributo: <xs:attribute name="lang" type="xs:string"/> Tipos de dados comuns do XML Schema XML Schema tem vários tipos de dados próprios.Atributos XSD <xs:element name="color" type="xs:string" default="red"/> Um valor fixo também é atribuído automaticamente ao elemento. Como definir um atributo A sintaxe para definir um atributo é: <xs:attribute name="xxx" type="yyy"/> onde xxx é o nome do atributo e yyy é o tipo de dado do atributo.

. Um valor padrão é atribuído automaticamente ao atributo quando nenhum outro valor é especificado. o valor fixo é "EN": <xs:attribute name="lang" type="xs:string" fixed="EN"/> Criando atributos opcionais e obrigatórios Todos atributos são opcionais por padrão. No exemplo seguinte. Você pode ler mais 11 .. você pode adicionar suas próprias restrições aos seus elementos e atributos XML. Mas. isto cria uma restrição ao conteúdo dele. Para especificar explicitamente que um atributo é opcional. Se um elemento XML é do tipo "xs:date" e contém um string como "Hello Mother". há mais. com XML Schemas. o elemento não vai ser validado. Você não pode especificar outro valor. No exemplo seguinte. Estas restrições são chamadas facets. utilize o atributo "use": <xs:attribute name="lang" type="xs:string" use="optional"/> Para fazer um atributo obrigatório: <xs:atrribute name="lang" type="xs:string" use="required"/> Restrições de conteúdo Quando um elemento ou um atributo XML tem um tipo definido. o valor padrão é "EN": <xs:attribute name="lang" type="xs:string" default="EN"> Um valor fixo é atribuído automaticamente ao atributo.Tipos de dados comuns do XML Schema • xs:string • xs:decimal • xs:integer • xs:boolean • xs:date • xs:time Declare valores padrão e fixo para atributos Atributos podem ter valores padrão OU fixo especificados.

Os valores aceitáveis são: Audi. 12 . O valor de age não pode ser menor que 0 ou maior que 100: <xs:element name="age"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="100"/> </xs:restriction> </xs:simpleType> </xs:element> Restrições em conjuntos de valores Para limitar o conteúdo de um elemento XML em um conjunto de valores aceitáveis. Este exemplo define um elemento chamado "car": <xs:element name="car"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value-"Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "carro" é um tipo simples com restrição. nós podemos usar restrições enumeradas.Restrições em conjuntos de valores sobre facets no próximo capítulo. Restrições em valores Este exemplo define um elemento chamado "age" com um restrição. Restrições em elementos XML são chamados facets. Golf. Restrições/facets XSD Restrições são usadas para controlar os valores aceitos para elementos e atributos XML.

Restrições em séries de valores Para limitar o conteúdo de um elemento XML em uma série de números ou letras. Este exemplo define o elemento chamado "letter": <xs:element name="letter"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-z]"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "letter" é do tipo simples com uma restrição. porque ele não é parte do elemento "car". podemos utilizar a restrição de padrão. O exemplo acima também poderia ser escrito assim: <xs:element name="car" type="carType"> <xs:simpleType name="carType"> <xs:restriction base="xs:string"> <xs:enumeration value="Audi"/> <xs:enumeration value="Golf"/> <xs:enumeration value="BMW"/> </xs:restriction> <xs:simpleType> Nota: Neste caso o tipo "carType" pode ser usado por outros elementos. O próximo exemplo define um elemento chamado "initials": <xs:element name="initials"> <xs:simpleType> <xs: restriction base="xs:string"> <xs:pattern value="[A-Z][A-Z][A-Z]"/> <xs:restriction> 13 .Restrições em séries de valores BMW. O único valor aceitável é UMA das letras MINÚSCULAS de a até z.

Este exemplo também define um elemento chamado "initials": <xs:element name="initials"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:patter value="[a-zA-Z][a-zA-Z][a-zA-Z]"/> </xs:restriction> <xs:simpleType> <xs:element> O elemento "initials" é do tipo simples com restrição.Restrições em séries de valores </xs:simpleType> <xs:element> O elemento "initials" é simples com um restrição. Este exemplo define um elemento chamado "choice": <xs:element name="choice"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[xyz]"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "choice" é um tipo simples com restrição. O próximo exemplo define um elemento chamado "prodid": <xs:element name="prodid"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:patter value="[0-9][0-9][0-9][0-9][0-9]"/> </xs:restriction> </xs:simpleType> 14 . O único valor aceitável é UMA das seguintes letras: x. y. OU z. O único valor aceitável são TRÊS letras MINÚSCULAS ou MAIÚSCULAS de a até z. O único valor aceitável são TRÊS letras MAiÚSCULAS de a até z.

O valor aceitável é zero ou mais ocorrências de letras minúsculas de a até z. O valor aceitável é uma ou mais ocorrências de um letra minúscula seguida de uma letra maiúscula de a até z. O único valor aceitável são CINCO dígitos em seqüência. Este exemplo define um elemento chamado "gender": <xs:element name="gender"> <xs:simpleType> 15 . Este exemplo também define um elemento chamado "letter": <xs:element name="letter"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="([a-z][A-Z])+"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "letter" é um tipo simples com um restrição. e cada dígito deve estar entre 0 e 9.Outras restrições em séries de valores </xs:element> O elemento "prodid" é um tipo simples com restrição. Outras restrições em séries de valores Algumas outras restrições que podem ser definidas por restrição de padrão: Este exemplo define um elemento chamado "letter": <xs:element name="letter"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="([a-z])*"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "letter" é um tipo simples com restrição.

Restrições em caracteres vazios <xs:restriction base="xs:string"> <xs:pattern value="male|female"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "gender" é um tipo simples com uma restrição. Deve haver exatamente oito caracteres e estes caracteres devem ser letras minúsculas ou maiúsculas de a até x. Restrições em caracteres vazios Para especificar como um caractere vazio deve ser tratado. qu significa que o processador XML NÂO VAI remover nenhum 16 . devemos usar a restrição whiteSpace. Este exemplo define um elemento chamado "adderess": <xs:element name="adress"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="preserve"/> <xs:restriction> </xs:simpleType> </xs:element> O elemento "adress" é um tipo simples com um restrição. Este exemplo define um elemento chamado "password": <xs:element name="password"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[a-zA-Z0-9]{8}"/> </xs:restriction> </xs:simpleType> <xs:element> O elemento "password" é um tipo simples com um restrição. ou um número de 0 a 9. A restrição whiteSpace é definida como "preserve". O único valor aceitável é male OU female.

espaços são substituídos com espaços. tabs. tabs. A restrição whiteSpace é definida como "replace". Este exemplo também define um elemento chamado "address": <xs:element name="address"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="collapse"/> </xs:restriction> </xs:simpleType> </xs:element> Este elemento "address" é um tipo simples com uma restrição. Este exemplo também define um elemento chamado "address": <xs:element name="address"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:whiteSpace value="replace"/> </xs:restriction> </xs:simpleType> </xs:element> Este elemento "address" é um tipo simples com um restrição. espaços múltiplos são reduzidos a um). nós usamos as restrições de comprimento. que significa que o processador XML VAI REMOVER todos caracteres vazios (quebras de linha. maxLength e minLength.Restrições de comprimento caractere vazio. espaços iniciais e finais são removidos. A restrição whiteSpace é definida como "collapse". Este exemplo define um elemento chamado "password": <xs:element name="password"> 17 . espaços) com espaços. Restrições de comprimento Para limitar o comprimento de um elemento. que significa que o processador XML VAI SUBSTITUIR todos caracteres vazios (quebras de linha.

Restrições para tipos de dados Restrição enumeration fractionDigits length maxExclusive maxInclusive maxLength Descrição Define uma lista de valores válidos Especifica o número máximo casas decimais permitidas. Deve ser igual ou maior que zero 18 . O valor deve ter exatamente oito caracteres. Deve ser igual ou maior que zero Especifica o valor máximo para valores numéricos (o valor deve ser menor que este valor) Especifica o valor máximo para valores numéricos (o valor deve ser menor ou igual a este valor) Especifica o número máximo de caracteres ou itens permitidos.Restrições para tipos de dados <xs:simpleType> <xs:restriction base="xs:string"> <xs:length value="8"/> </xs:restriction> </xs:simpleType> </xs:element> O elemento "password" é um tipo simples com uma restrição. Deve ser igual ou maior que zero Especifica o número exato de caracteres ou itens permitidos. Este exemplo define outro elemento chamado "password": <xs:element name="password"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:minLength value="5"/> <xs:maxLength value="8"/> </xs:restriction> </xs:simpleType> </xs:element> Este elemento "password" é um tipo simples com uma restrição. O valor deve ter no mínimo cinco e no máximo oito caracteres.

Deve ser igual ou maior que zero Define a seqÜência exata de caracteres permitidos Especifica o número exato de digitos permitidos. que contém apenas outros elementos: <employee> <firstname>John</firstname> 19 . espaços e retornos de carro) são tratados Elementos XSD complexos Um elemento complexo contém outros elementos e/ou atributos.Elementos XSD complexos minExclusive minInclusive minLength pattern totalDigits whiteSpace Especifica o valor mínimo para valores numéricos (o valor deve ser maior que este valor) Especifica o valor mínimo para valores numéricos (o valor deve ser maior ou igual a este valor) Especifica o número mínimo de caracteres ou itens permitidos. "employee". "product". O que é um elemento complexo ? Um elemento complexo é um elemento XML que contém outros elementos e/ou atributos. que é vazio: <product pid="1245"/> Um elemento XML complexo. Deve ser maior que zero Especifica como caracteres vazios (tabs. Há quatro tipos de elementos complexos: • elementos • elementos • elementos • elementos vazios que contém apenas outros elementos que contém apenas texto que contém tanto outros elementos quanto texto Nota: Cada um desses elementos podem conter atributos também! Exemplos de elementos XML complexos Um elemento XML complexo.

. O elemento "employee" pode ter um atributo tipo que faz referência ao nome do tipo complexo que deve ser usado: 20 . nomeando o elemento: <xs:element name="employee"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:sequence> </xs:complexType> </xs:element> Se você usar o método descrito acima. apenas o elemento "employee" pode usar o tipo complexo definido. O elemento "employee" pode ser declarado diretamente. Note que os elementos filhos.03.. "description". Você vai aprender sobre indicadores no capítulo Indicadores XSD. Isto significa que os elementos filhos devem aparecer na mesma ordem da declaração: "firstname" primeiro e "lastname" depois. que contém apenas outros elementos: <employee> <firstname>John</firstname> <lastname>Smith</lastname> </employee> Nós podemos definir um elemento complexo em um XML Schema de diferente maneiras: 1. "food". que contém outros elementos e texto: <description> It happened on <date lang="norwegian">03.Exemplos de elementos XML complexos <lastname>Smith</lastname> </employee> Um elemento XML complexo..99</date> . 2. são envolvidos pelo indicador <sequence>. </description> Como definir um elemento complexo Observe este elemento XML complexo. "firstname" e "lastname". que contém apenas texto: <food type="dessert">Ice cream</food> Um elemento XML complexo. "employee".

vários elementos podem fazer referência ao mesmo tipo complexo. assim: <xs:element name="employee" type="fullpersoninfo"/> <xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="personinfo" type="xs:string"/> </xs:sequence> </xs:complexType> <xs:complexType name="fullpersoninfo"> <xs:complexContent> <xs:extension base="personinfo"> <xs:sequence> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:extension> </xs:complexContent> <xs:complexType> 21 .Como definir um elemento complexo <xs:element name="employee" type="personinfo"/> <xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string/"> </xs:sequence> </xs:complexType> Se você usar o método descrito acima. assim: <xs:element name="employee" type="personinfo"/> <xs:element name="student" type="personinfo"/> <xs:element name="member" type="personinfo"/> <xs:complexType name="personinfo"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> Você também pode basear um elemento do tipo complexo em um tipo complexo existente e adicionar alguns elementos.

nós definimos um complexType tento complexContent. mas nós não declaramos nenhum elemento realmente. assim: <xs:element name="product"> <xs:complexType> <xs:complexContent> <xs:restriction base="xs:integer"> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:restriction> </xs:complexContent> </xs:complexType> </xs:element> No exemplo acima. assim: <xs:element name="product"> <xs:complexType> <xs:attribute name="prodid" type="xs:positiveInteger"/> </xs:complexType> </xs:element> Ou você pode dar um nome ao complexType.Elementos complexos vazios Elementos complexos vazios Um elemento complexo vazio pode conter atributos. apenas elementos. Entretanto. é possível declarar o elemento product de forma mais compacta.e. nós devemos definir um tipo que permita apenas elementos em seu conteúdo. O elemento complexContent diz que queremos restringir ou extender o modelo de conteúdo de um tipo complexo. Defina tipos complexos para elementos vazios Um elemento XML vazio: <product prodid="1345"/> O elemento "product" acima não tem conteúdo. e a restrição de inteiros declara um atributo mas não cria nenhum elemento. i. vários elementos podem referenciar o mesmo tipo complexo): 22 . mas não pode ter nenhum conteúdo entre as tags de abertura e fechamento. Para definir um tipo sem conteúdo. e fazer o elemento "product" ter um tipo que faz referência ao nome do complexType (se você usar este método.

assim: <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> Note a tag <xs:sequence>. Isto significa que os elementos definidos ("firstname" e "lastname") devem aparecer nesta ordem dentro do elemento "person". Ou você pode dar um nome ao complexType. que contém apenas outros elementos: <person> <firstname>John</firstname> <lastname>Smith</lastname> </person> Você pode definir o elemento "person" em um esquema. <xs:element name="person" type="persontype"/> <xs:complexType name="persontype"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> 23 . e um atributo type ao elemento "person" que faz referência a ele (se você usar este método. vários elementos podem referenciar o mesmo tipo complexo). Defina tipos complexos apenas com elementos Um elemento XML.Tipos complexos apenas elementos <xs:element name="product" type="prodtype"/> <xs:complexType name="prodtype"> <xs:atrribute name="prodid" type="xs:positiveInteger"/> </xs:complexType> Tipos complexos apenas elementos Um tipo complexo "apenas elementos" contém um elemento que contém apenas outros elementos. "person".

. e o elemento restriction para limitá-lo. que contém apenas texto: <shoesize country="france">35</shoesize> O exemplo a seguir declara um complexType. Aqui está um exemplo de um elemento XML.... </xs:restriction> </xs:simpleContent> </xs:complexType> </xs:element> Dica: Use o elemento extension para expandir o tipo simples base de um elemento. assim: <xs:element name="somename"> <xs:complexType> <xs:simpleContent> <xs:extension base="basetype"> .. "shoesize". Defina um elemento complexo apenas texto Este tipo contém apenas conteúdo simples (texto e atributos)... "shoesize". . . assim nós adicionamos um elemento simpleContent em torno do conteúdo. </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> OU <xs:element name="somename"> <xs:complexType> <xs:simpleContent> <xs:restriction base="basetype"> ... Quando usar conteúdo simples... O conteúdo é definido como tipo de dado integer e o elemento "shoesize" também contém um atributo chamado "country": 24 . você precisa definir uma extensão OU uma restrição com o elemento simpleContent..Elementos complexos apenas texto </xs:sequence> </xs:complexType> Elementos complexos apenas texto Um elemento complexo texto pode conter tanto atributos quanto texto.

Defina tipos complexos com conteúdo misto Um elemento XML. "orderid". e "shipdate" são todos filhos de "letter". que contém tanto outros elementos quanto texto: <letter> Dear Mr. e especificar um atributo type ao elemento "shoesize" que faz referência ao nome do complexType (se você usar este método. elementos. O seguinte esquema declara o elemento "letter": <xs:element name="letter"> <xs:complexType mixed="true"> 25 .<name>John Smith</nam> Your order <orderid>1032</orderid> wil be shipped on <shipdate>2001-07-13</shipdate>. "letter".Tipos complexos com conteúdo misto <xs:element name="shoesize"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:integer": <xs:attribute name="country" type="xs:string"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> Nós também poderíamos definir um nome para o complexType. </letter> Note o texto que aparece entre os elementos. vários elementos podem referenciar o mesmo tipo complexo): <xs:element name="shoesize" type="shoetype"/> <xs:complexType name="shoetype"> <xs:simpleContent> <xs:extension base="xs:integer"> <xs:attribute name="country" type="xs:string"/> </xs:extension> </xs:simpleContent> </xs:complexType> Tipos complexos com conteúdo misto Um elemento do tipo complexo misto pode conter atributos. "name". e texto.

orderid e shipdate) devem parecer nesta ordem no elemento "letter". A tag <xs:sequence> significa que os elementos definidos (name.Indicadores de tipos complexos <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType> <xs:element> Nota: Para permitir que caracteres apareçam entre os elementos filhos de "letter". e definir o atributo type de "letter" como uma referência a ele (se você usar este método. Nós também poderíamos dar um nome ao elemento complexType. o atributo mixed deve ser definido como "true". Indicadores Nós temos sete tipos de indicadores: Indicadores de ordem: • All • Choice • Sequence Indicadores de ocorrência: 26 . vários elementos podem fazer referência ao mesmo complexType): <xs:element name="letter" type="lettertype"/> <xs:complexType name="lettertype" mixed="true"> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="orderid" type="xs:positiveInteger"/> <xs:element name="shipdate" type="xs:date"/> </xs:sequence> </xs:complexType> Indicadores de tipos complexos Nós podemos controlar COMO os elementos serão usados em documentos através de indicadores.

Indicador choice O indicador <choice> especifica que um elemento filho ou outro pode ocorrer: <xs:element name="person"> <xs:complexType> <xs:choice> <xs:element name="employee" type="employee"/> <xs:element name="member" type="member"/> </xs:choice> </xs:complexType> </xs:element> 27 .Indicadores • maxOccurs • minOccurs Indicadores de grupo: • Group name • attributeGroup name Indicadores de ordem Indicadores de ordem são usados para definir a ordem em que os elementos ocorrem. e apenas uma vez: <xs:element name="person"> <xs:complexType> <xs:all> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:all> </xs:complexType> </xs:element> Nota: Usando o indicador <all> você pode especificar o indicador <minOccurs> em 0 ou 1 e <maxOccurs> só pode ser 1 (<minOccurs> e <maxOccurs> são descritos adiante). Indicador All O indicador <all> especifica por padrão que os elementos filhos podem aparecer em qualquer ordem e que cada um deve ocorrer.

Nota: Para todos indicadores "Order" e "Group" (any. all. sequence. choice.Indicador sequence Indicador sequence O indicador <sequence> especifica que os elementos filhos devem aparecer em uma ordem específica: <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> Indicadores de ocorrência Indicadores de ocorrência são usados para indicar com que freqüência um elemento pode ocorrer. Indicador minOccurs O indicador <minOccurs> especifica o número mínimo de vezes que um elemento pode ocorrer: 28 . e group reference) o valor padrão de maxOccurs e minOccurs é 1!!! Indicador maxOccurs O indicador <maxOccurs> especifica o número máximo de vezes que um elemento pode ocorrer: <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" name="child_name" type="xs:string" maxOccurs="10"/> </xs:sequence> </xs:complexType> </xs:element> O exemplo acima indica que o elemento "child_name" pode ocorre no mínimo uma vez (o valor padrão para minOccurs é 1) e no máximo dez vezes em um elemento "person". name. group.

29 .w3.xsd"> <person> <full_name>Hege Refsnes</full_name> <child_name>Cecilie</child_name> </person> <person> <full_name>Tove Refsnes</full_name> <child_name>Hege</child_name> <child_name>Stale</child_name> <child_name>Jim</child_name> <child_name>Borge</child_name> </person> <person> <full_name>Stale Refsnes</full_name> </person> </persons> O arquivo XML acima contém um elemento raiz chamado "persons".org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="family. Cada elemento "person" deve conter um elemento filho "full_name" e pode conter até cinco elementos filho "child_name".Indicador minOccurs <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" type="xs:string" maxOccurs="10" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:element> O exemplo acima indica que o elemento "child_name" pode ocorrer um mínimo de zero vezes e um máximo de dez em um elemento "person".0" encoding="ISO-8859-1"?> <persons xmlns:xs="http://www.xml": <?xml version="1. use a instrução maxOccurs="unbounded": Um exemplo prático Um arquivo XML chamado "Myfamily. Para permitir que um elemento pareça um número ilimitado de vezes. Dentro deste elemento está definido vários elementos "person".

Um exemplo prático Aqui está o esquema "family.0" encoding="ISO-8859-1"?> <xs:schema xmlns:xs="http://www.w3. Elementos de grupo Elementos de grupo são definidos com a declaração group.. que define um grupo de elementos que devem ocorrer em uma seqüência exata: <xs:group name="persongroup"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:element name="birthday" type="xs:date"/> </xs:sequence> 30 . assim: <xs:group name="groupname"> . ou sequence dentro da declaração group. choice.org/2001/XMLSchema" elementFormDefault="qualified"> <xs:element name="persons"> <xs:complexType> <xs:sequence> <xs:element name="person" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="full_name" type="xs:string"/> <xs:element name="child_name" type="xs:string" minOccurs="0" maxOccurs="5"/> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:schema> Indicadores de grupo Indicadores de grupo são usados para definir grupos de elementos relacionados. O exemplo seguinte define um grupo chamado "persongroup"..xsd": <xml version="1. </xs:group> Você deve deve definir um elemento all.

assim: <xs:attributeGroup name="groupname"> . você pode referenciá-lo na definição de outro grupo ou tipo complexo. assim: <xs:attributeGroup name="personattrgroup"> <xs:attribute name="firstname" type="xs:string"/> <xs:attribute name="lastname" type="xs:string"/> <xs:attribute name="birthday" type="xs:date"/> 31 . você pode referenciá-lo na definição de outro grupo ou tipo complexo...Elementos de grupo </xs:group> Depois que você definiu um grupo. </xs:attributeGroup> O exemplo a seguir define um grupo de atributos chamado "personattrgroup": <xs:attributeGroup name="personattrgroup"> <xs:attribute name="firstname" type="xs:string"/> <xs:attribute name="lastname" type="xs:string"/> <xs:attribute name="birthday" type="xs:date"/> </xs:attributeGroup> Depois que você definiu um grupo de atributos. assim: <xs:group name="persongroup"> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:element name="birthday" type="xs:date"/> </xs:sequence> </xs:group> <xs:element name="person" type="personinfo"/> <xs:complexType name="personinfo"> <xs:sequence> <xs:group ref="persongroup"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:complexType> Grupos de atributos Grupos de atributos são definidos com a declaração attributeGroup.

com" elementFormDefault="qualified"> <xs:element name="children"> <xs:complexType> <xs:sequence> <xs:element name="childname" type="xs:string" maxOccurs="unbounded"/> </xs:sequence> 32 .xsd".w3schools.Grupos de atributos </xs:attributeGroup> <xs:element name="person" <xs:complexType> <xs:attributeGroup ref="personattrgroup"/> </xs:complexType> </xs:element> O elemento <any> O elemento <any> nos permite extender o documento XML com elementos não especificados no esquema.com" xmlns="http://www.xsd": <?xml version="1.w3schools.w3.org/2001/XMLSchema" targetNamespace="http://www. Ele mostra uma declaração para o elemento "person".0" encoding="ISO-8859-1"?> <xs:schema xmlns:xs="http://www. O exemplo a seguir é um fragmento de um esquema XML chamado "family. Usando o elemento <any> nós podemos extender (depois de <lastname>) o conteúdo de "person" com qualquer elemento: <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> <xs:any minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:eleement> Agora nós queremos extender o elemento "person" com um elemento "children". chamado "children. mesmo que o autor do esquema acima nunca tenha declarado o elemento "children"! Observer esse arquivo de esquema. Neste caso nós podemos fazer isto.

xml").w3schools.com children.com family.O elemento <anyAttribute> </xs:complexType> </xs:element> </xs:schema> O arquivo XML abaixo (chamado "Myfamily.xsd"> <person> <firstname>Hege</firstname> <lastname>Refsnes</lastname> <children> <childname>Cecilie</childname> </children> </person> <person> <firstname>Stale</firstname> <lastname>Refsnes</lastname> </person> </persons> O arquivo XMl acima é válido porque o esquema "family.xsd": <?xml version="1.microsoft.xsd" e "children. usa componentes de dois esquemas diferentes.microsoft. "family.w3.xsd http://www.0" encoding="ISO-8859-1"?> <person xmlns="http://www.com" xmlns:xsi="http://www.xsd" nos permite extender o elemento "person" com um elemento opcional depois do elemento "lastname"! Os elementos <any> e <anyAttribute> são usados para fazer documentos EXTENSÍVEIS! Eles permitem aos documentos conterem elementos adicionais que não estão declarados no esquema XML! O elemento <anyAttribute> O elemento <anyAttribute> nos permite extender o documento XML com atributos que não foram especificados no esquema! O elemento <anyAttribute> O elemento <anyAttribute> nos permite extender o documento XML com atributos que não foram especificados no esquema. 33 .org/2001/XMLSchema-instance" xsi:SchemaLocation="http://www.

xsd". chamado "attribute.w3.xsd" e "attribute.microsoft.com" xmlns:xsi="http://www.com" xmlns="http://www.com" elementFormDefault="qualified"> <xs:attribute name="gender"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="male|female"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:schema> O arquivo XML abaixo (chamado "Myfamily.0" encoding="ISO-8859-1"?> <persons xmlns="http://www.microsoft.xsd http://www.com attribute.xml"). utiliza componentes de dois esquemas diferentes.xsd": <?xml version="1.w3schools. Neste caso nós podemos fazer isto. Usando o elemento <anyAttribute> nós podemos adicionar qualquer número de atributos ao elemento "person": <xs:element name="person"> <xs:complexType> <xs:sequence> <xs:element name="firstname" type="xs:string"/> <xs:element name="lastname" type="xs:string"/> </xs:sequence> <xs:anyAttribute/> </xs:complexType> </xs:element> Agora nós queremos extender o elemento "person" com um atributo "gender".xsd": <?xml version="1. Ele mostra uma declaração para o elemento "person".w3schools. mesmo que o autor do esquema acima nunca tenha declaro nenhum atributo "gender"! Observe este arquivo de esquema.xsd"> 34 .w3.O elemento <anyAttribute> O exemplo a seguir é um fragmento de um esquema XML chamado "family.com family. "family.org/2001/XMLSchema-instance" xsi:SchemaLocation="http://www.org/2001/XMLSchema" targetNamespace="http://w3schools.0" encoding="ISO-8859-1"?> <xs:schema xmlns:xs="http://www.

nós podemos definir um substitutionGroup no esquema XML.Substituição de elementos <person gender="female"> <firstname>Hege</firstname> <lastname>Refsnes</lastname> </person> <person gender="male"> <firstname>Stale</firstname> <lastname>Refsnes</lastname> </person> </persons> O arquivo XML acima é válido porque o esquema "family. Substituição de elementos Digamos que nós temos usuários de dois paises diferentes: Inglaterra e Noruega. o elemento "name" é o elemento chave e "navn" o elemento substituível para "name". Primeiro.xsd" nos permite adicionar um atributo ao elemento "person"! Os elemento <any> e <anyAttribute> são usado para fazer documentos EXTENSÍVEIS! Eles permitem aos documentos conterem elementos adicionais que não foram declarados no esquema XML! Substituição de elementos Com XML Schemas um elemento pode substituir outro. Observe esse fragmento de um esquema XML: <xs:element name="name" type="xs:string"/> <xs:element name="navn" substitutionGroup="name"/> 35 . Nós gostaríamos de permitir ao usuário escolher se quer usar os nomes de elementos em inglês ou norueguês no documento XML. nó declaramos um elemento chave e então nós declaramos outros elementos que são substituisões para o elemento chave: <xs:element name="name" type="xs:string"/> <xs:element name="navn" substitutionGroup="name"/> No exemplo acima. Para resolver este problema.

utilize o atributo block: <xs:element name="name" type="xs:string" block="substitution"/> Observe esse fragmento de um esquema XML: <xs:element name="name" type="xs:string" block="substitution"/> <xs:element name="navn" substitutionGroup="name"/> <xs:complexType name="custinfo"> <xs:sequence> <xs:element ref="name"/> </xs:sequence> </xs:complexType> <xs:element name="customer" type="custinfo" block="substituion"/> <xs:element name="kunde" substitutionGroup="customer"/> Um documento XML válido (de acordo com o esquema acima) parece-se com isso: 36 .Substituição de elementos <xs:complexType name="custinfo"> <xs:sequence> <xs:element ref="name"/> </xs:sequence> </xs:complexType> <xs:element name="customer" type="custinfo"/> <xs:element name="kunde" substitutionGroup="customer"/> Um documento XML válido (de acordo com o esquema acima) poderia parecer com isso: <customer> <name>John Smith</name> </customer> ou com isso: <kunde> <navn>John Smith</navn> </kunde> Bloqueando substituição de elementos Para prevenir que outros elementos substituam um elemento específico.

do tipo do elemento chave.w3. Note que todos elemento em um substitutionGroup (o elemento chave e os de substituição) de ser declarados como elementos globais. Você também aprenderá que um esquema pode ser escrito de diferentes maneiras. Se o tipo do elemento de substituição é o mesmo do elemento chave você não precisará especificá-lo. caso contrário não funcionará! O que são elementos globais? Elementos globais são aqueles que são filhos imediatos do elemento "schema"! Elementos locais são elementos aninhados a outros elementos! Um exemplo Este capítulo vai demostrar como escrever um XML Schema.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="shiporder.xml": <?xml version="1. ou derivdo.Um exemplo <customer> <name>John Smith</name> </customer> MAS ISSO NÃO É MAIS VÁLIDO: <kunde> <navn>John Smith</navn> </kunde> Utilizando substitutionGroup O tipo do elemento de substituição de ver o mesmo. Um documento XML Vamos dar uma olhada nesse documento XML chamado "shiporder.xsd"> <orderperson>John Smith</orderperson> <shipto> <name>Ola Nordmann</name> <address>Langgt 23</address> 37 .0" encoding="ISO-8859-1"?> <shiporder orderid="889923" xmlns:xsi="http://www.

..xsd".90</price> </item> <item> <title>Hide your heart</title> <quantity>1</quantity> <price>9. </xs:schema> 38 . .90</price> </item> </shiporder> O documento XML acima consiste de um elemento raiz.org/2001/XMLSchema"> .w3.xml"). A linha: xsi:noNamespaceSchemaLocation="shiporder.. A linha acima: xmlns:xsi="http://www.w3. um elemento opcional "note". "shipto" e "item". seguida do elemento xs:schema que define um esquema: <?xml version="1. que contém um atributo obrigatório chamado "orderid". Para criar o esquema nós podemos simplesmente seguir a estrutura no documento XML e definir cada elemento a medida que o encontramos. "shiporder"..org/2001/XMLSchema-instance" diz ao parser XML que o documento deve ser válidado por um esquema. O elemento "shiporder" contém três elementos filhos diferentes: "orderperson". Crie um XML Schema Agora nós vamos criar um esquema para o documento XML acima! Nós começamos abrindo um novo arquivo que chamaremos "shiporder. ele está no mesmo diretório que "shiporder.0" encoding="ISO-8859-1" ?> <xs:schema xmlns:xs="http://www.xsd" especifica ONDE o esquema reside (no caso. um elemento "quantity" e um "price". Nós vamos começar com a declaração XML padrão.Um documento XML <city>4000 Stavanger</city> <country>Norway</country> </shipto> <item> <title>Empire Burlesque</title> <note>Special Edition</note> <quantity>1</quantity> <price>10. O elemento "item" aparece duas vezes e contém um elemento "title".

.. nós temos que definir dois elementos que são do tipo complexo: "shipto" e "item". Este elemento pode aparecer muitas vezes dentro do elemento "shiporder". Este elemento tem um atributo e contém outros elemento..Crie um XML Schema No esquema acima nós usamos o namespace padrão (xs). nós temos que definir o elemento "shiporder".org/2001/XMLSchema. Em seguida. Isto é especificado definindo o atributo maxOccurs do 39 . e a URI associada com este namespace na linguagem de definição Schema. que tem o valor padrão http://www. O valor padrão para maxOccurs e minOccurs é 1!!! Agora nós podemos definir o elemento "item". Nós começamos definindo o elemento "shipto": <xs:element name="shipto"> <xs:complexType> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> Com esquemas nós podemos definir o número possível de ocorrências de um elemento com os atributos maxOccurs e minOccurs.. </xs:sequence> </xs:complexType> </xs:element> Então nós temos que definir o elemento "orderperson" como um tipo simples (porque ele não contém nenhum atributo ou elemento). O tipo (xs:string) é prefixado com o prefixo do namespace associado ao XML Schema que indica um tipo de dado pré-definido: <xs:element name="orderperson" type="xs:string"/> Em seguida.w3. Os elementos filhos de "shiporder" são englobados por um elemento xs:sequence que define uma ordem para eles: <xs:element name="shiporder"> <xs:complexType> <xs:sequence> . assim o consideramos um tipo complexo.. maxOccurs especifica o número máximo de ocorrências para um elemento e minOccurs o número mínimo.

xsd": <?xml version="1. Nós especificamos isto definindo o atributo minOccurs em zero: <xs:element name="item" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="note" type="xs:string" minOccurs="0"/> <xs:element name="quantity" type="xs:positiveInteger"/> <xs:element name="price" type="xs:decimal"/> </xs:sequence> </xs:complexType> </xs:element> Agora nós podemos declarar o atributo do elemento "shiporder".w3.0" encoding="ISO-8859-1" ?> <xs:schema xmlns:xs="http://www.Crie um XML Schema elemento "item" para "unbounded" que significa que podem haver tantas ocorrências do elemento "item" quanto o autor desejar. Como ele é um atributo obrigatório nós especificamos use="required".org/2001/XMLSchema"> <xs:element name="shiporder"> <xs:complexType> <xs:sequence> <xs:element name="orderperson" type="xs:string"/> <xs:element name="shipto"> <xs:complexType> <xs:sequence> <xs:element name="name" type="xs:string"/> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> </xs:sequence> </xs:complexType> </xs:element> <xs:element name="item" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="title" type="xs:string"/> <xs:element name="note" type="xs:string" minOccurs="0"/> <xs:element name="quantity" type="xs:positiveInteger"/> <xs:element name="price" type="xs:decimal"/> 40 . Note que o elemento "note" é opcional. Nota: As declaraçõs de atributos sempre devem vir no final: <xs:attribute name="orderid" type="xs:string" use="required"/> Aqui está a listagem completa do arquivo schema chamado "shiporder.

e então referenciá-los usando o atributo ref.definição de atributos --> <xs:attribute name="orderide" type="xs:string"/> <!-.w3.definição de elementos simples --> <xs:element name="orderperson" type="xs:string"/> <xs:element name="name" type="xs:string"/> <xs:element name="address" type="xs:string"/> <xs:element name="city" type="xs:string"/> <xs:element name="country" type="xs:string"/> <xs:element name="title" type="xs:string"/> <xs:element name="note" type="xs:string"/> <xs:element name="quantity" type="xs:positiveInteger"/> <xs:element name="price" type="xs:decimal"/> <!-.0" encoding="ISO-8859-1"?> <xs:schema xmlns:xs="http://www.xsd"): <?xml version="1. Aqui está a nova aparência o arquivo de esquema ("shiporder.definição de elementos complexos --> <xs:element name="shipto"> <xs:complexType> <xs:sequence> <xs:element ref="name"/> <xs:element ref="address"/> <xs:element ref="city"/> <xs:element ref="country"/> </xs:sequence> </xs:complexType> </xs:element> <xs:element name="item"> 41 .org/2001/XMLSchema"> <!-. mas pode ser muito difícil de ler e manter quando os documentos são complexos! O próximo método de design é baseado na definição de todos os elementos e atributos primeiro.Divida o schema </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="orderid" type="xs:string" use="required"/> </xs:complexType> </xs:element> </xs:schema> Divida o schema O método de design anterior é muito simples.

e então apontando para eles com o atributo type do elemento. que nos permite reutilizar a definição de elementos. Aqui está a nova forma do arquivo de esquema ("shiporder.Usando tipos nomeados <xs:complexType> <xs:sequence> <xs:element <xs:element <xs:element <xs:element </xs:sequence> </xs:complexType> </xs:element> ref="title"/> ref="note" minOccurs="0"/> ref="quantity"/> ref="price"/> <xs:element name="shiporder"> <xs:complexType> <xs:sequence> <xs:element ref="orderperson"/> <xs:element ref="shipto"/> <xs:element ref="item" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute ref="orderid" use="required"/> </xs:complexType> </xs:element> </xs:schema> Usando tipos nomeados O terceiro método de design define classes e tipos.w3.0" encoding="ISO-8859-1"?> <xs:schema xmlns:xs="http://www.xsd"): <?xml version="1.org/2001/XMLSchema"> <xs:simpleType name="stringtype"> <xs:restriction base="xs:string"/> </xs:simpleType> <xs:simpleType name="inttype"> <xs:restriction base="xs:positiveInteger"/> <xs:simpleType> <xs:simpleType name="dectype"> <xs:restriction base="xs:decimal"/> </xs:simpleType> <xs:simpleType name="orderidtype"> <xs:restriction base="xs:string"> <xs:pattern value="[0-9]{6}"/> 42 . Isto é feito nomeando os elementos simpleTypes e complexTypes.

esse fragmento: <xs:restriction base="xs:string"/> significa que o valor do elemento ou atributo de ser uma string. Observe as seguintes linhas do esquema acima: <xs:simpleType name="orderidtype"> <xs:restriction base="xs:string"> <xs:pattern value="[0-9]{6}"/> </xs:restriction> </xs:simpleType> 43 . O elemento restriction costuma ser mais usado para aplicar restrições nos elementos. Assim.Usando tipos nomeados </xs:restricion> </xs:simpleType> <xs:complexType name="shiptotype"> <xs:sequence> <xs:element name="name" type="stringtype"/> <xs:element name="address" type="stringtype"/> <xs:element name="city" type="stringtype"/> <xs:element name="country" type="stringtype"/> </xs:sequence> </xs:complexType> <xs:complexType name="itemtype"> <xs:sequence> <xs:element name="title" type="stringtype"/> <xs:element name="note" type="stringtype"/> <xs:element name="quantity" type="inttype"/> <xs:element name="price" type="dectype"/> </xs:sequence> </xs:complexType> <xs:complexType name="shipordertype"> <xs:sequence> <xs:element name="orderperson" type="stringtype"/> <xs:element name="shipto" type="shiptotype"/> <xs:element name="item" maxOccurs="unbounded" type="itemtype"/> </xs:sequence> <xs:attribute name="orderid" type="orderidtype" use="required"/> </xs:complexType> <xs:element name="shiporder" type="shipordertype"/> </xs:schema> O elemento restriction indica que o tipo de dado é derivado de um namespace de XML Schema do W3C.

retornos de carro. retornos de carro. Tipo de dado normalizedString O tipo de dado normalizedString é derivado do tipo de dado string. quebras de linha.Tipos de dados de string Isto indica que o valor do elemento ou atributo deve ser uma string e deve exatamente seis caracteres e cada caracter deve ser um número entre 0 e 9. A seguir está um exemplo de declaração de normalizedString em um esquema: <xs:element name="customer" type="xs:normalizedString"/> Um element em seu documento poderia ser assim: <customer>John Smith</customer> Ou assim: 44 . Tipos de dados de string Tipos de dados string são usados para valores que contém cadeias de caracteres. mas o processador XML vai removar quebras de linha. Ele também contém caracteres. A seguir está o exemplo de uma declaração de string em um esquema: <xs:element name="customer" type="xs:string"/> Um elemento em seu documento poderia ser assim: <customer>John Smith</customer> Ou assim: <customer> John Smith </customer> Nota: O processador XML não vai modificar o valor se você usar o tipo de dado string. e caracteres de tabulação. e caracteres de tabulação. Tipo de dado string O tipo de dado string pode conter caracteres.

o processador XML vai substituir a tabulação por espaços. espaços iniciais e finais. tabulação. Ele também contém caracteres.Tipo de dado normalizedString <customer>John Smith</customer> Nota: No exemplo acima. mas o processador XML vai remover quebras de linha. Tipo de dado token O tipo de dado token também é derivado do tipo de dado string. retornos de carro. Tipos de dados string Name ENTITIES ENTITY ID IDREF IDREFS language Name NCName Uma string que contém a id de uma linguagem válida Uma string que contém um nome XML válido Uma string que representa o atributo ID em XML (usado apenas com atributos de schema) Uma string que representa o atributo IDREF em XML (usado apenas com atributos schema) Description 45 . A seguir está um exemplo de declaração token em um esquema: <xs:element name="customer" type="xs:token"/> Um elemento em seu documento poderia ser assim: <customer>John Smith</customer> Ou assim: <customer> John Smith </customer> Nota: No exemplo acima o processador XML vai removar a tabulação. e espaços múltiplos.

onde: • YYYY indica o ano • MM indica o mês • DD indica o dia Nota: Todos componentes são obrigatórios! A seguir está um exemplo de declaração uma data em um schema: <xs:element name="start" type="xs:date"/> 46 . ou tabulação Uma cadeia de caracteres Um string que não contém quebras de linhs. IDREFS. espaços iniciais e finais. retornos de carro.Tipos de dados de data e hora NMTOKEN NMTOKENS normalizedString QName string token Uma string que representa o atributo NMTOKEN em XML (usado apenas com atributos schema) Uma string que não contém quebras de linha. retornos de carro. e ENTITIES não podem usar esta restrição) • whiteSpace Tipos de dados de data e hora Tipos de dados de data e hora são usados para valores que contém data e hora. ou múltiplos espaços Restrições em tipos de dados string Restrições que podem ser usados com tipos de dados string: • enumeration • lenght • maxLength • minLenght • pattern (NMTOKENS. Tipo de dado date O tipo de dado date é usado para especificar uma data. tabulação. A data é especificada da seguinte forma "YYYY-MM-DD".

como aqui: <start>2002-09-24-06:00</start> ou <start>2002-09-24+06:00</start> Tipo de dado time O tipo de dado time é usado para especificar um horário. onde: • hh indica a hora • mm indica os minutos • ss indica os segundos Nota: Todos componentes são obrigatórios! A seguir está um exemplo de declaração de um time em em schema: <xs:element name="start" type="xs:time"/> Um elemento em seu documento poderia ser assim: <start>09:00:00</start> Ou assim: <start>09:30:10. você pode usar uma data no horário UTC adicionando um "Z" depois da data. como aqui: <start>2002-09-24Z</start> ou você pode especificar uma área do horário UTC adicionando um horário positivo ou negativo depois da data.Tipo de dado date Um elemento em seu documento poderia ser assim: <start>2002-09-24</start> Time zones Para especificar um time zone (fuso horário). O horário é especificado da seguinte forma "hh:mm:ss".5</start> 47 .

O dateTime é especificado da seguinte forma "YYY-MM-DDThh:mm:ss".Time zones Time zones Para especificar um time zone (fuso horário). como aqui: <start>09:30:10Z</start> ou especificando uma área do horário UTC. você pode tanto usar um horário em UTC. onde: • YYYY indica o ano • MM indica o mês • DD indica o dias • T inidica o início da seção obrigatória time • hh indica a hora • mm indica os minutos • ss indica os segundos Nota: Todos componentes são obrigatórios! A seguir está um exemplo de uma declaração dateTime em um schema: <xs:element name="stardate" type="xs:dateTime"/> Um elemento em seu documento poderia ser assim: <startdate>2002-05-30T09:00:00</startdate> Ou assim: <startdate>2002-05-30T09:30:10. adicionando um "Z" ao final dele. como aqui: <start>09:30:10-06:00</start> ou <start>09:30:10+06:00</start> Tipo de dado dateTime O tipo de dado dateTime é usado para especificar uma data e um horário.5</startdate> 48 . adicionando um horário positivo ou negativo depois dele.

O intervalo de tempo é especificado da seguinte forma "PnYnMnDTnHnMnS". minutos ou segundos) • nH indica o número de horas • nM indica o número de minutos • nS indica o número de segundos A seguir está um exemplo de uma declaração de duration em um schema: <xs:element name="period" type="duration"/> Um elemento em seu documento poderia ser assim: <period>P5Y</period> O exemplo acima indica um período de cinco anos. você pode tanto utilizar um dateTime em UTC adicionado de um "Z". como aqui: <startdate>2002-05-30T09:30:10Z</startdate> ou especificando uma área do horário UTC.Time zones Time zones Para especificar um time zone (fuso horário). onde: • P indica o período (obrigatório) • nY indica o número de anos • nM indica o número de meses • nD indica o número de dias • T indica o início de uma seção de hora (obrigatório se você vai especificar horas. como aqui: <startdate>2002-05-30T09:30:10-06:00</startdate> ou <startdate>2002-05-30T09:30:10+06:00</startdate> Tipo de dado duration O tipo de dado duration é usado para especificar um intervalo de tempo. adicionando um horário positivo ou negativo ao horário. Ou assim: 49 .

o mês e o dia (MM-DD) Define uma parte de uma data .o dia (DD) Define uma parte de uma data . dez dias e 15 horas.o ano e o mês (YYYY-MM) time Define um valor de hora 50 .Tipo de dado duration <period>P5Y2M10D</period> O exemplo acima indica um período de cinco anos. dois meses e dez dias. Tipos de dados de data e hora Nome date dateTime duration gDay gMonth gMonthDay gYear Define um valor de data Define um valor de data e hora Define um intervalo de tempo Define uma parte de uma data .o mês (MM) Define uma parte de uma data . insira um sinal de menos antes de P: <period>-P10D</period> O exemplo acima indica um período de menos 10 dias. Ou assim: <period>P5Y2M10DT15H</period> O exemplo acima indica um período de cinco anos.o ano (YYYY) Descrição gYearMonth Define uma parte de uma data . Ou assim: <period>PT15H</period> O exemplo acima indica um período de 15 horas. dois meses. Duração negativa Para especificar uma duração negativa.

5230</prize> Ou assim: <prize>0</prize> Ou assim: <prize>14</prize> 51 .50</prize> Ou assim: <prize>+999.5450</prize> Ou assim: <prize>-999.Tipos de dados numéricos Restrições em tipos de dados date Restrições que podem ser usadas com tipos de dados date: • enumeration • maxExclusive • maxInclusive • minEsclusive • minInclusive • pattern • whiteSpace Tipos de dados numéricos Tipos de dados decimais são usados para armazenar números Tipo de dado decimal O tipo de dado decimal é usado para especificar um valor numérico. O exemplo a seguir é uma declaração de decimal em um schema: <xs:element name="prize" type="xs:decimal"/> Um elemento em seu documento poderia ser assim: <prize>999.

Tipo de dado decimal Nota: O número máximo de dígitos decimais que você pode especificar é 18! Tipo de dado integer O tipo de dado integer é usado para especificar um valor numérico sem um componente fracionário. O exemplo a seguir é uma declaração de um integer em um schema: <xs:element name="prize" type="xs:integer"/> Um elemento em seu documento poderia ser assim: <prize>999</prize> Ou assim: <prize>+999</prize> Ou assim: <prize>-999</prize> Ou assim: <prize>0</prize> Tipos de dados numéricos Note que todos os tipos de dados abaixo derivam do tipo de dado Decimal (exceto ele mesmo)! Nome byte decimal int integer long negativeInteger Um inteiro 8-bit com sinal Um valor decimal Um inteiro 32-bit com sinal Um valor inteiro Um inteiro 64-bit com sinal Um inteiro contendo apenas valores negativos (. -1) Descrição 52 .... -2.

Tipo de dado boolean O tipo de dado boolean é usado para especificar um valor true (verdadeiro) ou false (falso).Tipos de dados variados nonNegativeInteger Um inteiro contendo apenas valores não negativos (0.. hexBinary. 1.) Um inteiro 16-bit com sinal Um inteiro 64-bit sem sinal Um inteiro 32-bit sem sinal Um inteiro 16-bit sem sinal Um inteiro 8-bit sem sinal Restrições em tipos de dados numéricos Restrições que podem ser usadas com tipos de dados numéricos: • enumeration • fractionDigits • maxExclusive • maxInclusive • minExclusive • minInclusive • pattern • totalDigits • whiteSpace Tipos de dados variados Outros tipos de dados variados são boolean.. double. float. O exemplo a seguir é uma declaração de um boolean em um schema: <xs:attribute name="disabled" type="xs:boolean"/> Um elemento em seu documento poderia ser asism: 53 .. 0) Um inteiro contendo apenas valores positivos (1... e NOTATION.. . . base64Binary. -2. 2.. 2.) nonPositiveInteger positiveInteger short unsignedLong unsignedInt unsignedShort unsignedByte Um inteiro contendo apenas valores não positivos (. QName. -1. anyURI.

Tipos de dados variados Nome anyURI base64Binary boolean double Descrição 54 .w3schools. Nós temos dois tipos de dados binários: • base64Binary (dado binário codificado em Base64) • hexBinary (dado binário codificado em hexadecimal) O exemplo a seguir é uma declaração de um hexBinary em um schema: <xs:element name="blobsrc" type="xs:hexBinary"/> Tipo de dado anyURI O tipo de dado anyURI é usado para especificar uma URI. Tipos de dados binários Tipos de dados binários são usados para expressar dados binários.gif" /> Nota: Se uma URI tem espaços. O exemplo a seguir é uma declaração de um anyURI em um schema: <xs:attribute name="src" type="xs:anyURI"/> Um elemento em seu documento poderia ser assim: <pic src="http://www. 1 (que indica true). false. e 0 (que indica false).Tipo de dado boolean <prize disabled="true">999</prize> Nota: Valores válidos para boolean são true. substitua-os por %20.com/images/smiley.

com.br/dicas-l/20050326. em um curto espaço de tempo.novatec. a ler textos em inglês.Validador XSD float hexBinary NOTATION QName Restrições em tipos de dados variados Restrições que podem ser usados com outros tipos de dados: • enumeration (um tipo de dado Boolean não pode usar esta restrição) • length (um tipo de dado Boolean não pode usar esta restrição) • maxLength (um tipo de dado Boolean não pode usar esta restrição) • minLength (um tipo de dado Boolean não pode usar esta restrição) • pattern • whiteSpace Referência de elementos XSD Elementos XSD Validador XSD Validador XSD Versão Original: http://www. Saiba mais: http://www.dicas-l.br/livros/linguainglesa2/ 55 .php As Palavras Mais Comuns da Lingua Inglesa O livro As Palavras Mais Comuns da Língua Inglesa apresenta uma metodologia desenvolvida com o objetivo de prover o estudante com técnicas que lhe permitam aprender.com.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->