Tópicos de Sistemas
de Informação A
Carlos Oberdan Rolim
Ciência da Computação
Namespaces
Extensibilidade do XML
Dados XML são usados para intercâmbio entre
organizações
XML é extensível
XML permite autores de documentos criarem suas próprias tags,
definindo a origem dos elementos, atributos e tipos.
Em um ambiente distribuído os documentos XML precisam ser
gerenciados
Problemas da extensibilidade do XML
Exemplo: Uma lista dos filmes que estão em cartaz
Estendendo um documento existente
A lista de filmes pode ser estendida com um novo elemento que
corresponde a avaliação da qualidade do filme
Estendendo um documento existente
Documentos existentes são estendidos para acrescentar
novas informações
Se a extensão não for gerenciada corretamente podem
surgir problemas!
Extensões incompátiveis
Exemplo: A lista de filmes pode ser estendida com um novo
elemento que corresponde a avaliação do filme do ponto de
vista da censura
Extensões incompátiveis
As duas extensões são incompatíveis!
Ao combinar as duas avaliações em uma única listagem podem
surgir problemas
Combinando as duas listas
Extensões incompátiveis
Qual o problema?
Um software para filtrar apenas os filmes inofensivos ficaria perdido
Como distinguir os dois tags de avaliação?
Qual a solução?
Renomear os elementos
Renomeando os elementos
Renomeando os elementos relativos as avaliações (avaliação
de qualidade e avaliação de censura)
Solução
Não há como impedir que alguém estenda um documento
sem que este fique incompatível com outros documentos
Qual a solução?
Namespaces
Não limita a facilidade de extensão da XML, mas permite gerenciá-la.
São uma solução para gerenciar a extensibilidade de XML
Namespace pode ser definido como um mecanismo para identificar os
elementos e atributos de XML
Usando namespaces
Solução do namespace
Dois nomes diferentes são declarados para os elementos
avaliação
Um prefixo é incluído antes do nome de cada elemento
<qua:avaliação> 4 estrelas </qua:avaliação>
O prefixo identifica o tipo de avaliação
A declaração associa um prefixo a uma URI
Declaração de namespaces
É feita por meio de atributos utilizando-se o prefixo xmlns
seguido pelo prefixo
Exemplo:
<filmes xmlns:qua = “http://cinemas.com/1.0”
xmlns:cen = “http://filme.censura.com/1.0”
xmlns = “http://filmes.com/1.0 >
Resumindo
Os namespaces XML são um mecanismo para identificar de
modo não ambíguo quem desenvolveu determinado
elemento
São importantes em situações onde existem elementos com
mesmo nome representando diferentes conceitos
Nome do Namespace
É o URI e não o prefixo!
Dois elementos com prefixos diferentes, mas associados ao
mesmo URI são considerados idênticos
Declaração de Namespace
Associa um sistema de nomeação global (URIs) ao nome
dos elementos
URIs são usados para garantir a exclusividade dos nomes
URIs devem ser criados com base no seu próprio nome e
domínio
O papel do URI é puramente identificar unicamente os
elemento ou atributos
Uma URI identifica o proprietário do namespace, por isso
não é aconselhável usar o domínio de outras pessoas /
organizações
Atributos podem ter Namespaces
Tanto atributos quanto elementos podem ter namespaces
Escopo dos Namespaces
O namespace é válido
Para o elemento onde está declarado
Em todos os elementos dentro de seu conteúdo
Default Namespace
Se a maior parte dos elementos pertencem ao mesmo
namespace, não precisa usar prefixo para cada elemento.
Pode-se definir um namespace default que será aplicado
para todos os elementos e atributos que não tiverem prefixo.
A sintaxe é xmlns=”namespace”
Default namespace
<employees
xmlns="http://www.devxpert.com/schemas/hr/"
xmlns:py="http://www.devxpert.com/schemas/payroll/">
<employee>
<id>49982</id>
<name>Bart Simpson</name>
<hireDate>2000-07-04</hireDate>
<py:salary>4000765.00</py:salary>
<py:taxes>3980765.27</py:taxes>
</employee>
<employee>
<id>12345</id>
<name>Hugo Simpson</name>
<hireDate>2000-05-29</hireDate>
<py:salary>82000.00</py:salary>
<py:taxes>16567.87</py:taxes>
</employee>
</employees>
Default namespace
Default namespace é aplicado no elemento que é definido e
em todos os seus descendentes.
Se um desses descendentes usar outro default namespace
a sua declaração sobrescreve o anterior tornando-se o
default namespace para aquele elemento e todos os seus
descendentes.
Default namespace
<employees
xmlns="http://www.devxpert.com/schemas/hr/"
xmlns:py="http://www.devxpert.com/schemas/payroll/">
<employee>
<id>49982</id>
<name>Bart Simpson</name>
<hireDate>2000-07-04</hireDate>
<salary
xmlns="http://www.devxpert.com/schemas/payroll/”>
4000765.00
</salary>
<py:taxes>3980765.27</py:taxes>
</employee>
</employees>
Default namespace
<mydoc xmlns="uri:my-namespace">
</subnode />
</mydoc>
(Default namespace flows into the child - there is no
prefix, so it uses the default namespace)
<ns0:mydoc xmlns:ns0="uri:my-namespace">
<ns0:subnode />
</ns0:mydoc>
(No Default namespace, but ns0 maps to uri:mynamespace)
Default namespace
<ns0:mydoc xmlns:ns0="uri:my-namespace">
<ns1:subnode xmlns:ns1="uri:my-namespace" />
</ns0:mydoc>
(No Default namespace, but ns0 and ns1 both map to
uri:my-namespace and hence have identical meaning)
<ns0:mydoc xmlns:ns0="uri:my-namespace">
<subnode xmlns="uri:my-namespace" />
</ns0:mydoc>
(ns0 is defined on the parent, but we then set a default
namespace for this node - and any children, if it had any)
XML Schema
Validação de documentos XML
Recordando: para validar um documento XML
Um documento é válido com relação a um dado esquema XML se
obdece este esquema
Documento
XML
Parser
Esquema
XML
Documento
XML válido
Documento
XML inválido
Linguagens de Esquemas XML
DTD – Document Type Definition
XML Schema
Problemas dos DTDs
Sintaxe não XML
documento XML usando uma sintaxe e o DTD usando outra sintaxe
Não tem tipos de dados, em particular para o conteúdo dos
elementos  capacidade limitada de tipos de dados
DTDs suportam um conjunto muito limitado de tipos de dados. Não
podemos dizer “o elemento <salario> deve ser entre 240 e
3000,00”
Desejo de se ter um conjunto de tipos de dados compatíveis com
aqueles encontrados nos banco de dados
Só é marginalmente compatível com namespaces
XML Schema
Da mesma forma que a DTD
Utilizado para descrever a estrutura de um documento XML
XML Schemas são mais poderosos que DTDs:
Tipos de dados melhor especificado
+41 tipos e a capacidade de se criar tipos de dados definidos pelo
usuário
Escritos em XML (mesma linguagem dos documentos)
Podem expressar conjuntos (sets): um elemento filho pode estar em
qualquer ordem
Podem especificar unicidade (chaves)
Uso de técnicas de orientação a objetos
Número de elementos (“cardinalidade”)
Se um elemento é vazio ou pode incluir texto
XML Schema como sucessor da DTD
Algumas razões para isso:
É extensível
Estender/derivar tipos a partir já existentes
É mais rico e mais útil do que DTD
É escrita em XML
Suporta tipos de dados
Suporta namespaces
Define valores default e fixos para atributos e elementos
É uma W3C Recommendation
XML Schema Part 0: Primer
XML Schema Part 1: Structures
XML Schema Part 2: Datatypes
Também referida como XSDL: XML Schema Definition Language
Tipos
Suporte a tipos facilita
Descrever o que é ou não permitido no conteúdo de um elemento
Validar se um dado está correto
Trabalhar com dados vindos de um banco de dados
Definir facetas (restrições) aos dados
Definir padrões de dados (ou formatos)
Converter dados de tipos diferentes
Todos os elementos são associados a tipos!!
Sintaxe
Facilita...
Não é necessário aprender outra linguagem
Mesmo editor de texto
Mesmo parser
DOM
SAX
O esquema pode ser alterado usando XSLT
Declaração
Ao contrário de DTD
Em XMLSchema
Todas as declarações (elementos, atributos, etc.) são feitas
externamente ao documento XML
Não existe declaração interna (ou subconjunto interno)
No documento .xsd
Declaração
DTD
XML Schema
XML Schema
Declaração de chamada
Chamada da DTD
<?xml version=“1.0”?>
<!DOCTYPE artigo SYSTEM “artigo.dtd”>
<artigo>
<titulo> ... ... </titulo>
<autor>
<nome> ... ... </nome>
</autor>
</artigo>
Chamada do XML Schema
<?xml version="1.0"?>
<artigo xmlns="http://www.my.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=“c:/artigo.xsd">
<titulo> ... ... </titulo>
<autor>
<nome> ... ... </nome>
</autor>
<artigo>
Estrutura de um arquivo XML Schema
Elemento root:
<xs:schema>
<!-- declaração de tipos, elementos e atributos ->
</xs:schema>
Extensao do arquivo: .xsd
Alguns atributos de <schema>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema“
targetNamespace="http:// www.domain.com "
elementFormDefault="qualified">
<!– definições de elementos e atributos 
Define o
namespace do
</xs:schema>
XML Schema
Alguns atributos de <schema>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema“
targetNamespace="http://www.domain.com"
elementFormDefault="qualified">
<!– definições de elementos e atributos 
Especifica o namespace dos nomes dados aos
elementos e atributos do esquema sendo
definido
</xs:schema>
Alguns atributos de <schema>
<xs:schema
xmlns:xs="http://www.w3.org/2001/XMLSchema“
targetNamespace="http://www.domain.com "
elementFormDefault="qualified">
<!– definições de elementos e atributos 
</xs:schema>
Quaisquer elementos usados em instancias
XML (docs.xml) devem ser qualificados pelo
namespace, ou seja, devem possuir o prefixo
do namespace
Definição de Elemento
Uso da tag <xs:element>
Cria um elemento
Através do atributo name
Associa o elemento a um tipo
Através do atributo type
<XS:ELEMENT NAME=‘titulo’ TYPE=‘xs:string’/>
Definição de Atributo
Uso da tag <xs:attribute>
Cria um elemento
Através do atributo name
Associa o elemento a um tipo
Através do atributo type
<XS:ATTRIBUTE NAME=‘titulo’ TYPE=‘xs:string’/>
XML:
Exemplo
<email data=’01.01.2008’>
<de>[email protected]</de>
<para>undisclosed-recipients@...</para>
<assunto>reuniao</assunto>
<corpo fonte=‘Texto plano’>
Não esquecam da reuniao de amanha
</corpo>
</email>
XML Schema:
Exemplo
<xs:element
name=‘de’ type=‘xs:string’/>
<xs:element name=‘para’ type=‘xs:string’/>
<xs:element name=‘assunto’ type=‘xs:string’/>
<xs:element name=‘corpo’ type=‘xs:string’/>
<xs:attribute name=‘data’ type=‘xs:date’/>
<xs:attribute name=‘fonte’ type=‘xs:string’/>
Faltou o elemento email!!!!
Tipos Complexos
Descreve estruturas complexas, com subelementos e
atributos
<xs:complexType>
Definição de Elemento complexo
Definição de elemento complexo:
Uso de <xs:complexType>
Sintaxe 1:
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type=“xs:string“/>
<xs:element name=“fone" type="xs:integer"/>
<xs:element name=“email" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:element name=“funcionario” type=“tPessoa”/>
<xs:element name=“cliente” type=“tPessoa”/>
Definição de Elemento
Definição de elemento complexo:
Uso de <xs:complexType>
Sintaxe 2:
<xs:element name=“funcionario”>
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type="xs:string“/>
<xs:element name=“fone" type="xs:integer"/>
<xs:element name=“email" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Definição de atributo de um tipo complexo
O atributo deve ser colocado DEPOIS do sequence
<xs:element name=“funcionario”>
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type="xs:string“/>
<xs:element name=“fone" type="xs:integer"/>
<xs:element name=“email" type="xs:string"/>
</xs:sequence>
<xs:attribute name=“cpf" type="xs:string“/>
</xs:complexType>
</xs:element>
Declarações locais vs. globais
Pode-se declarar tipos, elementos e atributos globais ou locais
Declarações globais:
Declarados como filhos do elemento <schema>
Declarações podem ser reusadas
Declarações locais
Não são declarados como filhos de <schema>
Exemplo de declaração local
<xs:schema>
<xs:element name=“funcionario”>
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type=“xs:string“/>
<xs:element name=“fone" type=“xs:integer"/>
<xs:element name=“email" type=“xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Tipo
Tipoepode
elementos
ser usado
podem
apenas
ser usados
para o apenas
para
elemento
o elemento
endereço
funcionário
Exemplo de declaração global
<xs:schema>
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type=“xs:string“/>
<xs:element name=“fone" type=“xs:integer"/>
<xs:element name=“email" type=“xs:string"/>
</xs:sequence>Tipo Tipo
pode pode
ser usado
tipoapenas
de outros
elementos
sercomo
usado
para
o
como conteúdo
de outros elementos
</xs:complexType>Elemento pode usado
elemento
endereço
<xs:element name=“funcionario” type=“tPessoa”/>
<xs:element name=“cliente” type=“tPessoa”/>
</xs:schema>
Referência
Pode-se referenciar um elemento, ou atributo, que tenha sido declarado
anteriormente
Elemento, ou atributo, referenciado deve ser global
declarado no nível logo abaixo de schema
<xs:element name=“nome" type=“xs:string”/>
<xs:attribute name=“tipo" type=“xs:string”/>
…
<xs:complexType name=“tProduto">
<xs:sequence>
<xs:element ref=“nome"/>
<xs:element name=“modelo” type=“xs:string”/>
</xs:sequence>
<xs:attribute ref=“tipo“/>
</xs:complexType>
Referência
<xs:element name=“nome" type=“xs:string”/>
<xs:element name=“data“>
<xs:complexType>
<xs:element name=“dia” type=“xs:gDay”/>
<xs:element name=“mes” type=“xs:gMonth”/>
<xs:element name=“ano” type=“xs:gYear”/>
</xs:complexType>
</xs:element>
…
<xs:complexType name=“tPessoa">
<xs:sequence>
<xs:element ref=“nome"/>
<xs:element ref=“data"/>
<xs:element name=“modelo” type=“xs:string”/>
</xs:sequence>
</xs:complexType>
<xs:element name=“Funcionario” type=“tPessoa”/>
complexType
Define restrições para o modelo de conteúdo de um determinado
elemento
Especificação de cardinalidade
xs:minOccurs
xs:maxOccurs
Delimitadores de grupos de elementos
<xs:sequence>
<xs:choice>
<xs:all>
Cardinalidade
xs:minOccurs
número mínimo de vezes que um subelemento pode aparecer.
Default = 1
xs:maxOccurs
número máximo de vezes que um subelemento pode aparecer.
Default = 1.
Max = unbounded
Cardinalidade
<xs:complexType name="tProduto">
<xs:sequence>
<xs:element name=“nome" type="xs:string"/>
<xs:element name=“quantidade" type=“xs:integer“
minOccurs="0“ maxOccurs=“unbounded“/>
<xs:element name=“classificacao" type=“tClassific
minOccurs="0“ />
</xs:sequence>
</xs:complexType>
<xs:complexType name="tClassific">
<xs:sequence>
<xs:element name=“nome" type="xs:string“/>
<xs:element name=“email" type="xs:string“/>
</xs:sequence>
</xs:complexType>
Elementos mistos
Uso do atributo mixed
<xs:complexType name=“tSecao" mixed="true">
<xs:sequence>
<xs:element name=“paragrafo" type="xs:string"/>
<xs:element name=“referencia“ type=“xs:integer"/>
</xs:sequence>
</xs:complexType>
<xs:element name=“secao" type=“tSecao"/>
No XML:
<secao>
esta é uma secao com texto e elementos
Exercício
Construa um XMLSchema, de tal forma que o seguinte documento XML possa ser
validado:
<notaFiscal>
<cliente>
<razao_social>JOAQUIM</razao_social>
<cgc>00.000.000/0001-00</cgc>
<obs>esta observação é sobre <sobre>clientes especiais</sobre>
</obs>
</cliente>
<item>
<produto>caneta azul</produto>
<quantidade>100</quantidade>
<preco_unit>2</preco_unit>
</item>
</notaFiscal>
Valores para elementos
<xs:element name=“email" type=“xs:string“
default=“[email protected]"/>
Valor por omissão
<xs:element name=“supervisor" type=“xs:string“
fixed=“José Carlos Ramalho"/>
Valor fixo
Delimitadores de grupo
<xs:sequence>
subelementos devem aparecer na instância XML na mesma ordem em que foram
declarados no esquema
<xs:choice>
somente um dos elementos declarados no grupo pode aparecer na instância
<xs:all>
os elementos do grupo podem aparecer uma vez JUNTOS ou nenhuma vez e
podem aparecer em qualquer ordem
Sequence - exemplo
No XML Schema:
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type=“xs:string"/>
<xs:element name=“fone" type=“xs:integer“/>
<xs:element name=“email" type=“xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:element name=“Funcionario” type=“tPessoa”/>
Na instancia XML:
<Funcionario>
<nome>Osvaldo da Silva</nome>
<fone>1212121</fone>
<email>[email protected]</email>
</Funcionario>
Sequence – comparando com DTD
No XML Schema:
<xs:complexType name="tPessoa">
<xs:sequence>
<xs:element name=“nome" type=“xs:string"/>
<xs:element name=“fone" type=“xs:integer“/>
<xs:element name=“email" type=“xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:element name=“Funcionario” type=“tPessoa”/>
Na DTD:
<!ELEMENT Funcionario (nome, fone, email)>
<!ELEMENT nome (#PCDATA)>
<!ELEMENT fone (#PCDATA)>
<!ELEMENT email (#PCDATA)>
Choice - exemplo
No XML Schema:
<xs:complexType name="tPublic">
<xs:sequence>
<xs:element name=“nome” type=“xs:string”/>
<xs:choice>
<xs:element name=“ISBN" type=“xs:integer"/>
<xs:element name=“volume" type=“xs:integer“/>
</xs:choice>
</xs:sequence>
</xs:complexType>
<xs:element name=“publicacao” type=“tPublic”/>
Na instancia XML:
<publicacao>
<nome>Projeto de Banco de dados</nome>
<ISBN>989898989</ISBN>
</publicacao>
<publicacao>
<nome>SQL Magazine</nome>
<volume>9</volume>
</publicacao>
Choice – comparando com a DTD
No XML Schema:
<xs:complexType name="tPublic">
<xs:sequence>
<xs:element name=“nome” type=“xs:string”/>
<xs:choice>
<xs:element name=“ISBN" type=“xs:integer"/>
<xs:element name=“volume" type=“xs:integer“/>
</xs:choice>
</xs:sequence>
</xs:complexType>
<xs:element name=“publicacao” type=“tPublic”/>
Na DTD:
<!ELEMENT publicacao (nome, (ISBN | volume))>
<!ELEMENT nome (#PCDATA)>
<!ELEMENT ISBN (#PCDATA)>
<!ELEMENT volume (#PCDATA)>
All - exemplo
No XML Schema:
<xs:complexType name=“tAut">
<xs:all>
<xs:element name=“nome” type=“xs:string”/>
<xs:element name=“email" type=“xs:integer"/>
<xs:element name=“instituicao" type=“xs:string“/>
</xs:all>
</xs:complexType>
<xs:element name=“autor” type=“tAut”/>
Na instancia XML:
<autor>
<nome>Ana Clara</nome>
• Todos juntos ou nada
• Sem restrição de ordem
<email>[email protected]</email>
<instituicao>Universidade XYZ</instituicao>
</autor>
All – comparando com a DTD
No XML Schema:
<xs:complexType name=“tAut">
<xs:all>
<xs:element name=“nome” type=“xs:string”/>
<xs:element name=“email" type=“xs:integer"/>
<xs:element name=“instituicao" type=“xs:string“/>
</xs:all>
</xs:complexType>
<xs:element name=“autor” type=“tAut”/>
Na DTD:
<!ELEMENT autor (nome | email | instituicao)?>
<!ELEMENT nome (#PCDATA)>
<!ELEMENT email (#PCDATA)>
<!ELEMENT instituicao (#PCDATA)>
Elementos vazios
Declarar elemento somente com atributo:
<xs:element name=“figura”>
<xs:complexType>
<xs:attribute name=“nome”>
</xs:complexType>
<xs:element>
Instancia XML:
<figura nome=“foto”/>
Derivação de Tipos Simples
Tipos simples
Derivados de tipos simples através de
restrição.
Processo:
Um tipo simples é usado com base
sobre ele são aplicadas
facetas ou
expressões regulares.
Restrições ou facetas
length: define o comprimento de um tipo de dados
minLength: define o comprimento mínimo de um tipo de dados
maxLength: define o comprimento máximo de um tipo de dados
pattern: define a expressão regular (Regular Expressions) a ser utilizada na
validação do tipo
enumaration: limita os valores possíveis de um tipo de dados a um conjunto
previamente especificado
whiteSpace: define como devem ser tratados os espaços em branco.
Restrições ou facetas
minInclusive: limite mínimo considerando o valor especificado
minExclusive: limite mínimo desconsiderando o valor especificado
maxInclusive: limite máximo considerando o valor especificado
maxExclusive: limite máximo desconsiderando o valor especificado
totalDigits: número máximo de dígitos considerando a parte inteira e a parte
decimal
fractionDigits: número máximo de casas decimais
Facetas
Faceta “exclusive”
Limita um tipo simples a valores mínimo e máximo
<xs:simpleType name="tNumero">
<xs:restriction base=“xs:integer">
<xs:minExclusive value="0"/>
<xs:maxExclusive value="99999"/>
</xs:restriction>
</xs:simpleType>
Facetas
A faceta “enumeration”
Limita um tipo simples a um conjunto de valores distintos
<xs:simpleType name="TipoFigura">
<xs:restriction base="xs:string">
<xs:enumeration value = "jpeg"/>
<xs:enumeration value = "gif"/>
<xs:enumeration value = "bmp"/>
<xs:enumeration value = "tiff"/>
<xs:enumeration value = "wmf"/>
</xs:restriction>
</xs:simpleType>
<xs:attribute name="tipo" type="TipoFigura“/>
Facetas
Comparando o enumeration no XMLSchema com a DTD:
** XMLSchema
<xs:simpleType name="TipoFigura">
<xs:restriction base="xs:string">
<xs:enumeration value = "jpeg"/>
<xs:enumeration value = "gif"/>
<xs:enumeration value = "bmp"/>
<xs:enumeration value = "tiff"/>
<xs:enumeration value = "wmf"/>
</xs:restriction>
</xs:simpleType>
<xs:attribute name="tipo" type="TipoFigura“/>
** DTD (só é possível delimitar valores para atributos)
<!ELEMENT figura ANY>
<!ATTLIST figura
tipo NOTATION (jpeg|gif|bmp|tiff|wmf)>
Facetas
Faceta “pattern”
Possibilita a criação de máscaras para os valores
<xs:simpleType name="tCep">
<xs:restriction base="xs:string">
<xs:pattern value="\d{5}-\d{3}"/>
</xs:restriction>
</xs:simpleType>
....
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="male|female"/>
</xs:restriction>
</xs:simpleType>
Facetas
Facetas “fractionDigits”, “minInclusive” e “maxInclusive”
Possibilita definir como manipular tipos de dados como decimal ou float por exemplo
Exemplo:
Construção de um tipo “número de filhos”
Nesse caso precisamos utilizar como tipo de dados base o tipo decimal, eliminar a quantidade
de casas decimais, permitir apenas números positivos (incluindo o zero) e opcionalmente
determinar um valor máximo (se seguirmos o Guinness Book esse valor é 900). O fragmento
XML abaixo define uma das possibilidades de como esse tipo pode ser criado:
<xsd:simpleType name="tNumeroFilhos">
<xsd:restriction base="xsd:decimal">
<xsd:fractionDigits value="0"/>
<xsd:minInclusive value="0"/>
<xsd:maxInclusive value="900"/>
</xsd:restriction>
</xsd:simpleType>
Facetas
Facetas “minLength”, “maxLength” e “whiteSpace”
Possibilita definir como manipular tipos de dados como string por exemplo
Exemplo:
Construção de um tipo de dados Nome
Admitindo-se que o tipo de dados “nome” seja um texto com comprimento mínimo de 4
caractéres e máximo de 100 caractéres e que os espaços em branco duplicados devam ser
substituídos por um único espaço em branco (“André
do Nascimento” por “André do
Nascimento”), pode-se construir o tipo de dados nome da seguinte forma:
<xsd:simpleType name="tNome">
<xsd:restriction base="xsd:string">
<xsd:minLength value="4"/>
<xsd:maxLength value="100"/>
<xsd:whiteSpace value="collapse"/>
</xsd:restriction>
</xsd:simpleType>
Construção através de extensão por união
Exemplo:
Construir tipo por união significa dizer que o
tipo construído assumirá todos os valores
<xsd:simpleType name="tIdade">
possíveis de seus tipos base. Esse tipo de
<xsd:restriction base="xsd:decimal">
construção não é muito comum na construção
<xsd:minExclusive value="0"/>
de documentos XSD, mas ainda assim
<xsd:fractionDigits value="0"/>
representa uma possibilidade.
<xsd:maxInclusive value="80"/>
</xsd:restriction>
A construção de tipos através de extensão por
união necessita do atributo “union” e do
elemento “memberTypes” para representar que
o tipo de dados será construído através de
extensão por união e quais tipos servirão como
tipos base
</xsd:simpleType>
<xsd:simpleType
name="tDataPersonalizada">
<xsd:restriction base="xsd:date">
<xsd:minInclusive value="1950-01-01"/>
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType name="tIdadeOuData">
<xsd:union memberTypes="tIdade
tDataPersonalizada"/>
</xsd:simpleType>
Os tipos de dados primitivos
xs:string
xs:boolean
xs:decimal
xs:float
xs:double
xs:duration
xs:dateTime
xs:time
xs:date
xs:gYearMonth
xs:gYear
xs:gMonthDay
xs:gDay
xs:gMonth
xs:hexBinary
xs:base64Binary
xs:anyURI
xs:QName
xs:NOTATION
Exercício
Construir o XMLSchema para validar um documento XML com o
cadastro de acesso de vários usuários de um site com as seguintes
restricoes:
O nome de um cliente com tamanho mínimo de 10 caractéres e tamanho
máximo de 90 caractéres
Um nick name com no mínimo dois caractéres e no máximo 20
caractéres
Um e-mail válido
Uma senha numérica com no mínimo seis e no máximo oito números
O ano de nascimento (superior a 1950 e menor ou igual a 1992)
O estado de origem (opcional)
Uma opção (sim ou não) para controlar se seus dados (nome, e-mail, ano
de nascimento e UF) podem ser visualizados por outros usuários
Exercicios
XML para ser utilizado no exercicio
<usuarios>
<usuario>
<nome> Carlos Oberdan Rolim </usuario>
<nickname>Ober </nickname>
<email>[email protected] </email>
<senha>minhasenha</senha>
<anonascimento>1992</anonascimento>
<uf>RS</uf>
<visualizadados>S</visualizadados>
</usuario>
</usuarios>