Monografia Marcelo Mendonça Xlpath

FACULDADE DE CIÊNCIA E TECNOLOGIA – ÁREA 1
MARCELO MENDONÇA DOS SANTOS
XLPATH:
UMA LINGUAGEM PARA NAVEGAÇÃO EM LINKS XML
SALVADOR
2010
XLPATH:
Uma Linguagem Para Navegação em Links XML
Trabalho de Conclusão de Curso

apresentado ao Programa de Graduação
do Curso de Engenharia de Computação
da Faculdade Área 1, como requisito para
obtenção do grau de Bacharel em
Engenharia de Computação.
Orientador: Prof. Paulo Caetano da Silva
SALVADOR
2010
XLPATH:
Uma Linguagem Para Navegação em Links XML
Trabalho de Conclusão de Curso

apresentado ao Programa de Graduação
do Curso de Engenharia de Computação
da Faculdade Área 1, como requisito para
obtenção do grau de Bacharel em
Engenharia de Computação.
Aprovada em 30 de junho de 2010.
BANCA EXAMINADORA
Alexandre do Nascimento Silva – Mestre em Modelagem Computacional

Fundação Visconde de Cairu
Wanja Marly de Oliveira Mascarenhas – Mestre em Modelagem Computacional

Fundação Visconde de Cairu
Paulo Caetano da Silva – Mestre em Redes de Computadores

Universidade Salvador - UNIFACS
AGRADECIMENTOS
Agradeço a meus pais, Gilberto e Mariluce, pelas portas abertas.

À minha namorada, Maílla, pelo incentivo em todos os momentos.
Aos meus amigos, sobretudo o Professor Paulo Caetano, por acreditar na minha
capacidade, e Jader do Monte, pela ajuda com a programação.
“Ria e o mundo rirá com você.
Chore e você chorará sozinho.”
ELLA WHEELER WILCOX
RESUMO
A rápida expansão de XML enquanto padrão de representação e intercâmbio

de dados ocasionou o surgimento de tecnologias que complementam as
funcionalidades dessa linguagem. Em algumas situações, as soluções
desenvolvidas passaram a compartilhar com a própria XML a tarefa de representar a
semântica inerente aos dados, como é o caso dos esquemas de dados baseados
em XML Schema e dos links providos por XLink. Como consequência, há uma forte
demanda por ferramentas especializadas que facilitem a manipulação dessas
estruturas. Neste contexto estão inseridas as linguagens de consulta. O presente
trabalho propõe XLPath, uma linguagem path voltada para navegação em links XML,
que permite a realização de consultas refinadas sobre os elementos que compõem
os links.
Palavras-chave: XLPath, XLink, XML, Linguagem de Consulta.

ABSTRACT
The quick expansion of XML as standard of representation and exchanging of

data led to the arising of technologies that complement the features of this language.
In some situations, the developed solutions have come to share with the XML itself
the task of representing the inherent semantics to the data, as it is the case of the
data schemas based on XML Schema and the links provided by XLink. As a
consequence, there is strong demand for specialized tools that facilitate the
manipulation of these structures. In this context are inserted the query languages.
This paper proposes XLPath, a path language turned to navigation on XML links,
which allows to perform refined queries on the elements that compose the links.
Keywords: XLPath, XLink, XML, Query Language.

LISTA DE FIGURAS
Figura 1. Encadeamento de Documentos XML ......................................................... 19
Figura 2. Árvore de Elementos XML ......................................................................... 21
Figura 3. Mecanismos de XPath ............................................................................... 23
Figura 4. Abordagens XSPath em Alto e Baixo Nível................................................ 25
Figura 5. Link Estendido em Abordagem de Baixo Nível .......................................... 36
Figura 6. Link Estendido em Abordagem de Alto Nível ............................................. 37
Figura 7. Arquitetura de um Processador XLPath ..................................................... 46
Figura 8. Console do Processador XLPath ............................................................... 47
Figura 9. Resultados no Console XLPath ................................................................. 48

LISTA DE QUADROS
Quadro 1. Exemplo de Link Estendido ...................................................................... 17
Quadro 2. Exemplos de Elementos XML .................................................................. 20
Quadro 3. Resultado de Uma Consulta XPath+......................................................... 28
Quadro 4. Algoritmo NavigationPath ......................................................................... 33
Quadro 5. Link Estendido Grade Curricular............................................................... 35
Quadro 6. Equivalente Estendido de um Link Simples.............................................. 38
Quadro 7. Notação EBNF para XLPath ..................................................................... 44
Quadro 8. Saída do Processador XLPath ................................................................. 49

LISTA DE TABELAS
Tabela 1. Tipos de Elementos e Atributos Globais em XLink.................................... 18
Tabela 2. Eixos de XPath .......................................................................................... 22
Tabela 3. Especificação de Nó em XPath ................................................................. 22
Tabela 4. Exemplos de Expressões XSPath ............................................................. 26
Tabela 5. Simbologia para Representação de Links ................................................. 34
Tabela 6. Especificação de Eixo em XLPath ............................................................. 41
Tabela 7. Especificação de Elemento em XLPath..................................................... 43
Tabela 8. Predicados em XLPath .............................................................................. 44

SUMÁRIO
1. INTRODUÇÃO ................................................................................................... 12
1.1. MOTIVAÇÃO ................................................................................................ 12
1.2. OBJETIVOS ................................................................................................. 13
1.3. ESTRUTURA DO DOCUMENTO ................................................................ 14
2. CONTEXTUALIZAÇÃO ..................................................................................... 15
2.1. XLINK ........................................................................................................... 15
2.2. XPATH ......................................................................................................... 19
2.3. XSPATH ....................................................................................................... 24
2.4. XPATH+ ........................................................................................................ 26
2.5 CONCLUSÃO .............................................................................................. 29
3. XLPATH: UMA LINGUAGEM PARA NAVEGAÇÃO EM LINKS XML .............. 30
3.1. REQUISITOS PARA XLPATH ..................................................................... 30
3.2. UM MODELO DE DADOS PARA XML COM XLINK .................................... 31
3.3. REPRESENTAÇÃO DE LINKS .................................................................... 33
3.3.1. Representação em baixo nível ........................................................... 34
3.3.2. Representação em alto nível .............................................................. 36
3.4. ABORDAGEM PARA LINKS SIMPLES ....................................................... 37
3.5. ABORDAGEM PARA LINKS COM ARCOS IMPLÍCITOS............................ 38
3.6. SINTAXE E SEMÂNTICA............................................................................. 39
3.6.1. Especificação de eixo ......................................................................... 40
3.6.2. Especificação de elemento ................................................................. 41

3.6.3. Predicado ............................................................................................. 42
3.7. ARQUITETURA DE UM PROCESSADOR XLPATH ................................... 45
3.8. CONCLUSÃO .............................................................................................. 46
4. ESTUDO DE CASO ........................................................................................... 47
4.1. PROTÓTIPO DE UM PROCESSADOR XLPATH ........................................ 47
4.2. CONCLUSÃO .............................................................................................. 50
5. CONCLUSÃO ..................................................................................................... 52
REFERÊNCIAS......................................................................................................... 53
APÊNDICE A – escola_de_filosofia.xml ................................................................ 55
APÊNDICE B - XLPathConsole.java ....................................................................... 57
APÊNDICE C - XLPathFormatter.java .................................................................... 61
APÊNDICE D - XLPathExpression.java ................................................................. 63
APÊNDICE E - XLPathStep.java ............................................................................. 65
APÊNDICE F - XLPathElementStore.java .............................................................. 70
APÊNDICE G - XLPathExecutor.java ..................................................................... 73
APÊNDICE H - XLPathProcessor.java ................................................................... 75

12
1. INTRODUÇÃO
Desde que se tornou uma recomendação do W3C (World Wide Web

Consortium) [20], em 1998, XML, acrônimo para eXtensible Markup Language [17],
vem tendo sua utilização difundida pelas mais diversas áreas do conhecimento,
servindo como base para inúmeras aplicações de software, sobretudo aquelas que
têm a Internet como meio principal para intercâmbio de dados.
Como consequência dessa rápida expansão, há uma forte demanda por

tecnologias que complementem suas funcionalidades. Nos últimos anos, várias
soluções com esse propósito têm sido desenvolvidas, como, por exemplo: (i) XML
Schema [24], que permite a criação de regras para validação de documentos XML;
(ii) XSLT (Extensible Stylesheet Language Transformations) [26], que possibilita a
conversão desses documentos para outros formatos; e (iii) XLink (XML Linking
Language) [21], que provê mecanismos para criação de links entre recursos XML.
Essas tecnologias se tornaram padrões e, assim como a própria XML,

receberam o status de recomendação do W3C. Algumas delas, em determinadas
aplicações, passaram a compartilhar com XML a tarefa de representar a semântica
inerente aos dados, como é o caso das taxonomias baseadas em XML Schema e
XLink. Com isso, o desenvolvimento de ferramentas que viabilizem a manipulação
dos dados não se restringe à própria XML, passando a ser uma necessidade comum
às suas tecnologias complementares.
1.1. MOTIVAÇÃO
Dentre as mais importantes ferramentas de apoio às estruturas de

manutenção de dados, estão as linguagens de consulta. Elas automatizam a
inserção, recuperação e manipulação dos dados, de forma dinâmica e flexível, tarefa
essa que se torna impraticável para os usuários à medida que cresce o volume de
dados armazenados em uma estrutura. A mais conhecida dessas linguagens é a
SQL (Structured Query Language) [27], destinada às consultas em bancos de dados
relacionais. Em se tratando de dados XML, XQuery (XML Query Language) [25],
uma recomendação do W3C, provê uma sintática e semântica similares às de SQL,
permitindo a formulação de consultas que utilizam cláusulas como where e order by,
13
dentre outras, que estão presentes também em SQL. Além de XQuery, o W3C
desenvolveu XPath (XML Path Language) [22], uma linguagem path que, assim
como a primeira, permite a manipulação de dados estruturados em XML, porém com
o diferencial de oferecer mecanismos mais simplificados.
As linguagens path constituem um meio natural de se navegar pela estrutura

característica de XML, permitindo que partes específicas das informações sejam
selecionadas. No que tange às instâncias, XPath desempenha esse papel com
eficácia. Porém, para outros tipos de estruturas XML, como esquemas e links,
soluções mais especializadas se fazem necessárias, uma vez que XPath não provê
mecanismos que possibilitem uma navegação que explore as características
peculiares dessas estruturas. Exemplo disso são os referenciamentos entre
elementos e tipos, existentes de maneira implícita nos esquemas, e os
referenciamentos explícitos característicos dos links, ambos inexploráveis por meio
de XPath.
1.2. OBJETIVOS
O presente trabalho propõe XLPath (XML Linking Path Language), uma

linguagem path voltada para a navegação sobre as redes de referenciamento
formadas pelos links providos por XLink.
Para a construção dessa linguagem, os seguintes objetivos específicos foram

elencados:
• Definir uma formalização matemática;
• Levantar os requisitos inerentes à navegação através de links;
• Desenvolver a sintaxe e a semântica;
• Implementar um protótipo de processador dessa linguagem para

comprovar a eficácia da mesma em consultas sobre links XML.
14
1.3. ESTRUTURA DO DOCUMENTO
Este trabalho está organizado da seguinte maneira:
• Capítulo 2, Contextualização – Discute os principais conceitos

envolvidos na criação de links através de XLink e investiga a aplicabilidade das
linguagens de consulta para explorá-los;
• Capítulo 3, XLPath: Uma Linguagem para Navegação em Links XML –

Enumera os requisitos para a construção da linguagem de navegação sobre links e
propõe uma sintaxe e semântica para atendê-los, bem como uma arquitetura de um
processador para essa linguagem;
• Capítulo 4, Estudo de Caso – Descreve um protótipo de processador

para XLPath e avalia o seu desempenho na realização de consultas sobre links;
• Capítulo 5, Conclusão – Discute os resultados obtidos com a realização

deste trabalho, apresenta as conclusões finais e aponta possibilidades de trabalhos
futuros relacionados a este projeto.
15
2. CONTEXTUALIZAÇÃO
Esta seção discute XLink, tecnologia para criação de links em documentos

XML, e linguagens destinadas à navegação nestes documentos, XPath, XSPath [2]
e XPath+ [10], buscando verificar a aplicabilidade dessas linguagens à navegação
sobre links.
2.1. XLINK
O modelo de links oriundo de HTML (HyperText Markup Language) [18] é

essencialmente estático e unidirecional, i.e. estático porque uma vez codificada em
uma página HTML, a ligação não sofre mais alterações; unidirecional porque os links
têm somente uma direção explícita de associação e, consequentemente, de
navegação entre os recursos. Além disso, se restringem a associar um único recurso
de origem a um único recurso de destino, sendo que os links precisam estar
necessariamente embutidos no código do recurso de origem [8].
Esse tipo de link é interessante para se fazer associações entre diferentes

trechos de uma mesma página Web, ou entre trechos de uma página local e
recursos remotos, tais como outras páginas, conteúdos multimídia, dentre outros. Os
recursos são referenciados através de seu URI (Uniform Resource Identifier) [1],
declarado como valor do atributo href do link. O código a seguir exemplifica um link
HTML: <a href=”example.html”> Link </a>.
Contudo, em se tratando de representar os complexos relacionamentos que

podem existir entre recursos XML, o mecanismo dos links HTML se mostra
insuficiente. Por exemplo, em uma estrutura XML criada para representar uma
biblioteca, onde há relacionamentos entre autores e obras, em um sentido a relação
é do autor para com o livro e, no outro, do livro para com o autor. Para atender XML,
um link deve ser capaz de representar semânticas como essa.
Como solução, o W3C desenvolveu a especificação XLink, uma linguagem

para criação de links em documentos XML. Em XLink, os links podem ser simples ou
estendidos. Estes primeiros têm funcionalidades e propósitos semelhantes àquelas
dos links HTML, ou seja, associam somente dois recursos – um local e outro remoto
– com um arco partindo do primeiro para o segundo. Um link desse tipo é dito
16
outbound, e pode ser declarado através de qualquer elemento XML que contenha o
atributo type, do namespace XLink, com o valor “simple”. O código seguinte
representa um link simples: <book xlink:type=”simple” xlink:href=”...”>Book’s
Name</book>.
Os links estendidos oferecem novas e poderosas funcionalidades, como a

possibilidade de se fazer ligações do tipo inbound – quando o recurso de destino é
local e o de origem, remoto – e third-party – quando ambos, origem e destino, são
remotos. Além disso, links estendidos possibilitam associar um número arbitrário de
recursos participantes numa ligação. Porém, é importante destacar que uma
travessia de um link, seja este simples ou estendido, sempre envolverá um par de
recursos (ou partes de um) [21].
Outra particularidade dos links estendidos é que estes podem ter uma
estrutura bastante complexa, sendo possível que determinados elementos sejam
declarados como seus filhos diretos, desempenhando alguns papéis, que incluem:
(i) Elementos do tipo locator, que referenciam recursos remotos

participantes no link;
(ii) Elementos do tipo arco (arc), que provêem regras de travessia entre os
recursos participantes no link;
(iii) Elementos do tipo título (title), que provêem informações a respeito do

link que devem ser entendidas por pessoas; e
(iv) Elementos do tipo recurso (resource), que fornecem recursos locais

que participam do link.
O Quadro 1 apresenta a estrutura de um link estendido para uma biblioteca,

representando os relacionamentos anteriormente mencionados, entre autores e
obras.
17
Quadro 1. Exemplo de Link Estendido
<bibliotecaLink xlink:type="extended">
<livro xlink:href="livros.xml#oBanquete"
xlink:label="livro01" xlink:type="locator "
xlink:title=”O Banquete” />
<livro xlink:href="livros.xml#retorica"
xlink:label="livro02" xlink:type="locator”
xlink:title=”Retórica” />
<autor xlink:href="autores.xml#platao"
xlink:label="autor01” xlink:type="locator"
xlink:title=”Platão” />
<autor xlink:href="autores.xml#aristoteles"
xlink:label="autor02" xlink:type="locator"
xlink:title=”Aristóteles” />
<go xlink:type="arc" xlink:from="autor01"
xlink:to="livro01" xlink:title="Livro publicado"
xlink:arcrole=”http://www.exemplo.br/autor-livro” />
<go xlink:type="arc" xlink:from="autor02"
xlink:to="livro02" xlink:title="Livro publicado"
xlink:arcrole=”http://www.exemplo.br/autor-livro” />
<go xlink:type="arc" xlink:from="livro01"
xlink:to="autor01" xlink:title="Autor do livro"
xlink:arcrole=”http://www.exemplo.br/livro-autor” />
</bibliotecaLink>
Outra característica importante de XLink são seus atributos globais, que são
aqueles que utilizam o namespace de XLink. Eles podem ser classificados segundo
a finalidade, conforme abaixo:
(i) Atributo de tipo de elemento (type) – identifica o tipo do elemento

XLink;
(ii) Atributo de localização (href) – fornece os dados que permitem uma

aplicação XLink localizar um recurso remoto;
(iii) Atributos de semântica (role, arcrole e title) – descrevem o significado

de recursos dentro do contexto de um link;
(iv) Atributos de comportamento (show e actuate) – sinalizam como

aplicações XLink devem tratar o link;
(v) Atributos de travessia (label, from e to) – referenciam recursos que

serão conectados por um arco.
18
Esses atributos podem ser utilizados de maneira combinada em elementos

XLink. As possíveis combinações dependem diretamente do tipo do elemento em
que estes atributos aparecem, sendo que esse tipo é definido pelo valor do atributo
type. A Tabela 1 mostra as possíveis combinações entre os tipos dos elementos
(colunas) e os atributos globais (linhas), com uma indicação de quando um valor
para aquele atributo é requerido (R) ou opcional (O).
Tabela 1. Tipos de Elementos e Atributos Globais em XLink [21]
Tipos de Elementos
simple extended locator arc resource title
type R R R R R R
href O -------- R -------- -------- --------
role O O O -------- O --------

Atributos Globais
arcrole O -------- -------- O -------- --------
title O O O O O --------
show O -------- -------- O -------- --------
actuate O -------- -------- O -------- --------
label -------- -------- O -------- O --------
from -------- -------- -------- O -------- --------
to -------- -------- -------- O -------- --------
Dada a complexidade que as estruturas de links estendidos podem alcançar

ao disporem das funcionalidades providas por XLink, muitas vezes pode ser
interessante agrupar estes links em documentos separados, contribuindo para a
organização e manipulação dos mesmos. Esse agrupamento de links em um
documento distinto recebe o nome de linkbase.
Uma instância ou um esquema de dados XML podem referenciar um linkbase

através de um link (simples ou estendido) contendo um atributo arcrole com o valor
“http://www.w3.org/1999/xlink/properties/linkbase”. Além disso, linkbases podem
referenciar outros linkbases. Somando-se a isso o fato de esquemas também
19
poderem referenciar outros esquemas, e de instância, esquemas e linkbases

possuírem arcos internos, um complexo encadeamento de documentos é formado,
onde os links desempenham um importante papel na representação da semântica
daquele contexto. A Figura 1 ilustra esse cenário, onde as setas representam links
existentes entre os diferentes documentos mencionados e as elipses representam
arcos que compõem alguns desses links.
Figura 1. Encadeamento de Documentos XML [10]
Portanto, XLink incrementa de maneira significativa o papel desempenhado

pelos links, promovendo-os de simples conexões entre recursos de páginas Web, a
importantes mecanismos de representação semântica em modelos de dados
baseados em XML. Contudo, mesmo com tamanha importância, há ainda uma
carência por mecanismos que possibilitem sua completa manipulação, como
linguagens de consulta que ofereçam meios de se aplicar um maior grau de
refinamento às consultas.
2.2. XPATH
XML provê um meio para descrever dados através de uma rica, flexível e
eficiente estrutura de marcação, que fornece metadados encapsulados em etiquetas
20
(tags). Entretanto, essa linguagem não oferece um meio de se localizar partes

específicas desses dados dentro de um determinado documento. Dessa forma, para
se localizar alguma informação, faz-se necessário que o usuário analise o
documento, elemento por elemento, até alcançar os dados desejados. Segundo [4],
este processo será tão ineficiente e propenso a erros quanto maior for a quantidade
de dados contidos no documento em questão.
Como solução, o W3C desenvolveu a linguagem XPath, que conta com o

status de recomendação do referido órgão. Essa linguagem, atualmente em sua
versão 2.0, provê uma sintaxe capaz de identificar, de maneira efetiva e eficiente,
partes específicas de um documento XML (e.g., valores de atributos). Ao contrário
de XML, que tem como característica marcante o seu aspecto estruturado, XPath é
uma linguagem de expressões não-estruturadas, baseadas em strings, utilizada por
outras tecnologias XML, tais como XSLT e XPointer (XML Pointer Language) [23],
uma linguagem que provê meios de se apontar para partes específicas de um
documento XML.
Uma forma conceitual de se olhar para um documento XML é imaginá-lo

como uma árvore, onde cada parte do documento representa um nó (node), sendo
que cada nó pode conter um número ilimitado de outros nós. Além disso, há
exatamente um único nó raiz (root) que contém todos os outros nós. A Figura 2
ilustra a árvore XML que reflete os nós dos elementos apresentados no Quadro 2.
Nesses termos, XPath é uma linguagem para capturar nós (ou grupos deles) dessa
árvore [6]. A partir de sua perspectiva, XPath reconhece sete tipos de nós: root,
element, text, attribute, comment, processing-instruction e namespace.
Quadro 2. Exemplos de Elementos XML
<livraria>
<livro categoria=”filosofia”>
<titulo lang=”pt”>A República</titulo>
<autor>Platão</autor>
<ano>2005</ano>
<preco>24.90</preco>
</livro>
</livraria>
21
Segundo Harold e Means [6], as expressões XPath mais utilizadas são as

chamadas location path. Essas expressões especificam como navegar em uma
árvore XML de um nó a outro. Uma location path é composta por passos (steps),
que por sua vez contêm um eixo, uma especificação de nó e um predicado, sendo
que este último é opcional. Para se localizar um nó específico em um documento
XML, podem ser combinados vários passos, onde cada um deles é avaliado em
relação a um nó em particular chamado nó de contexto.
Root element:
<livraria>
Parent
Child
Attribute: Element: Attribute:
lang <livro> categoria
Element: Element: Element: Element:

<titulo> <autor> <ano> <preco>
Siblings
Text: Text: Text: Text:
A República Platão 2005 24.90
Figura 2. Árvore de Elementos XML (Adaptada de [15])
Um eixo indica quais nós, relativos ao nó de contexto, deverão ser incluídos

na consulta. A Tabela 2 apresenta alguns dos eixos de XPath e uma breve descrição
de cada um.
A aplicação de um eixo resulta em um grupo de nós selecionados a partir da

árvore do documento XML. Para que este resultado seja refinado, é utilizada a
especificação de nó [4]. Exemplos desse mecanismo juntamente com uma breve
descrição são mostrados na Tabela 3.
Para os casos em que o grau de refinamento obtido com a especificação de

nó não é suficiente, a busca pode ser refinada ainda mais com a utilização de
predicados. Um predicado contém uma expressão booleana que é testada para
cada nó presente na lista obtida como resultado da especificação de nó. Se a
22
expressão for verdadeira para um dado nó, então o mesmo é mantido na lista. Caso
contrário, o nó é deletado [6].
Tabela 2. Eixos de XPath
Eixo Descrição
self O próprio nó de contexto
parent O pai do nó de contexto, se existir
child Os filhos do nó de contexto, caso existam
ancestor Os ancestrais do nó de contexto, caso existam
Os ancestrais do nó de contexto, incluindo o

ancestor-or-self
próprio
descendant Os descendentes do nó de contexto
Os descendentes do nó de contexto, incluindo o

descendant-or-self
próprio
XPath provê algumas funções que podem ser utilizadas em predicados, como
por exemplo a função last( ), que retorna o número de nós de uma lista, e position( ),
cujo resultado é a posição do nó que está sendo testado. Além disso, predicados
também podem conter alguns operadores, tais como aritméticos, comparativos,
dentre outros.
Tabela 3. Especificação de Nó em XPath
Especificação Descrição
* Seleciona todos os nós do mesmo tipo do nó principal
node( ) Seleciona todos os nós, independente do tipo
text( ) Seleciona todos os nós de texto
comment( ) Seleciona todos os nós de comentários
node name Seleciona todos os nós com o nome especificado

23
A utilização conjunta dos mecanismos providos por XPath para formar

expressões location path, torna essa linguagem uma poderosa ferramenta para
localização de dados estruturados em documentos XML. A Figura 3 ilustra o
gradativo aumento de precisão em uma expressão XPath, aplicada à árvore da
Figura 2, à medida que são processados os mecanismos de refinamento de
consultas.
Contudo, é importante frisar que XPath é ideal para realização de consultas

em documentos de instância. Para outros tipos de documentos baseados em XML,
soluções mais especializadas foram propostas. As seções seguintes discutem
XSPath, uma linguagem de consulta para XML Schemas; e XPath+, que tem foco em
consultas sobre links.
Root element:
<livraria>
Element:
<livro>
Attribute: Attribute:
lang categoria
Element: Element: Element: Element:

<titulo> <autor> <ano> <preco>
Text: Text: Text: Text:

A República Platão 2005 24.90
/descendant::livro[ano=’2005’]/ano
Figura 3. Mecanismos de XPath
24
2.3. XSPATH
Quando um documento XML é produzido, muitas vezes se faz necessário

validar o seu conteúdo. Validações podem ser efetuadas com base em documentos
que contém regras que definem uma determinada instância como, por exemplo, os
tipos de elementos que devem ser declarados e a hierarquia que deve existir entre
eles.
Atualmente, a validação de instâncias XML é feita através de esquemas de

dados produzidos com base na linguagem XML Schema. Essa linguagem é uma
recomendação do W3C, criada com o objetivo suprir as deficiências do padrão DTD
(Document Type Definition) [13], originalmente desenvolvido para validação de
documentos SGML (Standard Generalized Markup Language) [3], e que mais tarde
passou a ser utilizada também em XML. Dentre essas deficiências, pode-se citar a
falta de suporte aos namespaces [19].
Um exemplo de utilização de XML Schema é o Projeto Nota Fiscal Eletrônica

(NF-e) da Receita Federal [9], o qual, segundo a mesma, “tem como finalidade a
alteração da sistemática atual de emissão da nota fiscal em papel, por nota fiscal
eletrônica com validade jurídica para todos os fins”. Isso é prova do espaço que XML
Schema vem ganhando enquanto tecnologia padrão de validação de dados em
XML, o que ocasiona a necessidade de desenvolvimento de ferramentas para
facilitar a manipulação de seus dados, tais como as linguagens de consulta.
Devido à natureza hierárquica de XML Schema, expressões de navegação

sobre sua estrutura são um meio natural de recuperar seus principais componentes.
Dessa forma, sendo os esquemas, em essência, documentos XML, uma
possibilidade seria utilizar diretamente a linguagem XPath para produzir expressões
de navegação sobre os mesmos. Contudo, isso resultaria na especificação de
expressões complexas e que não retornariam o esperado pelos usuários no
momento de sua formulação [2].
Como alternativa, Cavalieri et al. [2] propõem XSPath, uma linguagem que
deriva de XPath, porém com foco em consultas sobre documentos XML Schema.
Em XSPath, a noção de consultas realizadas em passos é estendida para permitir a
25
navegação através das ligações entre os tipos dos elementos contidos no esquema,
inclusive dentro da estrutura hierárquica dos tipos complexos [14].
Em relação a estes últimos, nem sempre há interesse em explorar os

operadores que definem sua estrutura complexa. Por conta disso, XSPath oferece
duas abordagens distintas de navegação: expressões de baixo nível (low level), que
analisam a estrutura interna de tipos complexos, e expressões de alto nível (high
level), cujos passos independem de como elementos são combinados através de
operadores para formar tipos complexos.
A Figura 4 mostra ambas as abordagens a partir de uma árvore que

representa um esquema de dados. Neste caso, o esquema modela um e-mail. É
possível observar que em alto nível (árvore à direita) os operadores sequence e
choice foram omitidos, pois dizem respeito à estrutura interna dos tipos subjectType,
mailType, envelopeType e anonymT, todos complexos.
Figura 4. Abordagens XSPath em Alto e Baixo Nível [2]
Assim sendo, as expressões XSPath, cuja forma geral é similar à de uma

expressão location step de XPath – um eixo, uma especificação de nó e um
(opcional) predicado –, passam a ser precedidas de um indicador de nível de
abstração: LL para low level, e HL para high level.
26
A Tabela 4 traz exemplos de expressões XSPath e os índices dos itens

obtidos como resultado para as seguintes consultas:
(i) Encontrar o elemento picture, dentro de attachment, no elemento mail;
(ii) Encontrar o atributo header, dentro de evelopeType;
(iii) Encontrar os elementos do tipo subjectType;
(iv) Encontrar os tipos simples que utilizem uma restrição de pattern;
(v) Encontrar o operador choice, dentro de attachment, no elemento mail.
Tabela 4. Exemplos de Expressões XSPath
Expressão XSPath Resultado
/HL::child::element(mail)/HL::child::element(attachment)
i {23}
/HL::child::element(picture)/
ii /HL::child::type(envelopeType)/HL::child::attribute(header) {18}
iii /HL::descendant-or-self::element()[/#HL::child::type()=’subjectType’ {14, 15}
iv /HL::descendant-or-self::type()[restriction(pattern)] {27}
/HL::child::element(mail)/HL::child::element(attachment)
v {22}
/LL::child::operator(sequence)/LL::child::operator(choice)
Estes resultados demonstram a aplicabilidade de XSPath no que tange à

navegação sobre esquemas de dados baseados em XML Schema. Contudo, em se
tratando dos links providos por XLink, nenhum mecanismo que permita navegar
através de suas estruturas é fornecido por essa linguagem, ainda que esses links
possam referenciar elementos do próprio esquema. Na próxima seção será discutida
XPath+, uma linguagem desenvolvida para consultas sobre links.
2.4. XPATH+
Conforme anteriormente discutido, parte da semântica de uma estrutura de

dados XML pode ser delegada aos links estendidos providos por XLink. Esses links
27
podem aparecer tanto nas instâncias, como nos esquemas, ou ainda agrupados em
linkbases, formando redes de links.
Segundo Silva e Times [10], o processamento de documentos contendo

essas redes tem se tornado uma tarefa desafiadora, uma vez que as linguagens de
consulta não suportam técnicas de travessia entre os links. Como resultado, tanto a
semântica quanto as questões de processamento relacionadas aos links são
comprometidas.
Com o objetivo de preencher essa lacuna, os referidos autores [10] propõem

a linguagem XPath+, uma extensão de XPath, cuja principal característica é permitir
consultas sobre arcos que compõem links. XPath+ é capaz de localizar arcos,
estejam eles em uma instância, em um esquema, ou em um linkbase.
Os principais mecanismos providos por XPath+ são os eixos link-source e link-

destination, cuja sintaxe é similar àquela dos eixos child e parent de XPath. Através
desses eixos é possível navegar pelos arcos que referenciam recursos XML, sejam
eles elementos locais ou remotos.
Quanto à semântica, o eixo link-source seleciona uma lista de nós que têm o
nó de contexto como recurso de origem, enquanto o link-destination executa a
operação inversa, ou seja, seleciona uma lista de nós que têm o nó de contexto
como recurso de destino.
Além disso, no sentido de facilitar a navegação através de elementos que

contêm links, XPath+ provê algumas funções que complementam aquelas fornecidas
por XPath. Estas funções incluem:
(i) fn:isLinkSource($arg as item()* ) as item()* - Função que retorna um

valor booleano que indica se o nó de contexto é uma origem de link, isto é, se há
algum link cujo atributo from aponta para o nó de contexto;
(ii) fn:isLinkDestination($arg as item()* ) as item()* - Função que retorna

um valor booleano que indica se o nó de contexto é um destino de link, isto é, se há
algum link cujo atributo to aponta para o nó de contexto.
28
Para ilustrar o funcionamento de XPath+, a expressão /link-destination::platao,

juntamente com o documento que contém o link estendido visto no exemplo do
Quadro 1, foram submetidos ao protótipo de processador dessa linguagem
apresentado por Silva e Times [10].
De acordo com o resultado da consulta, que pode ser visto no Quadro 3, a

expressão detecta a existência do arco do qual o elemento platao é o destino. Isso
comprova a eficácia dessa linguagem no que tange à localização de arcos em
documentos XML.
Quadro 3. Resultado de Uma Consulta XPath+

Role: http://www.exemplo.br/livro-autor
Exist arc between oBanquete and platao
Entretanto, é importante notar que, de acordo com o que foi anteriormente

discutido a respeito de XLink, os arcos são apenas partes que compõem os links.
Em outras palavras, um elemento arco é um dos possíveis filhos de um elemento
link estendido, já que XLink não obriga que um link estendido contenha arcos.
Segundo a especificação de XLink [21], se nenhum arco for declarado, deve-se
considerar que há arcos implícitos ligando, de todas as formas possíveis, todos os
locators do link em questão. Assim sendo, ao invés de uma linguagem de consultas
sobre links de um modo geral, XPath+ se caracteriza como uma linguagem destinada
à localização de arcos.
Além disso, essa linguagem não provê mecanismos para elaboração de

consultas com um maior grau de refinamento. Em situações onde haja mais de um
arco apontando ou sendo apontado pelo nó de contexto, caberá ao usuário a tarefa
de analisar a lista de elementos obtida como resultado, para então localizar o arco
de seu interesse. Obviamente, quanto maior a quantidade de elementos detectados,
maior será o esforço exigido nessa tarefa, bem como a suscetibilidade a erros.
Outra carência de XPath+ é a falta de suporte a consultas sobre links simples.

Uma vez que este tipo de link não permite a declaração de arcos, consultas
baseadas nessa linguagem serão incapazes de detectá-los.
29
2.5 CONCLUSÃO
Como pôde ser notado, dentre as linguagens analisadas, XPath+ é a única

que, de fato, oferece mecanismos capazes de tratar os relacionamentos por
referenciamento característicos dos links, consistindo em uma ferramenta eficaz no
que se refere à identifição de arcos e dos elementos por eles referenciados. Porém,
essa linguagem carece de características importantes em se tratando de linguagens
path, como a possibilidade de se especificar um caminho de navegação dentre
aqueles possíveis, através de condições previamente definidas pelo usuário.
Como alternativa, o presente trabalho propõe XLPath, uma linguagem que

combina mecanismos como: (i) expressões location path, de XPath; (ii)
especificação de nível de abstração, de XSPath; e (iii) eixos de especificação de
origem e destino de arcos, de XPath+. Com isso, essa linguagem busca viabilizar
consultas efetivas sobre os links de XLink, quer sejam estes simples ou estendidos,
permitindo a navegação através dos elementos que compõem a sua rede de
referenciamentos, além de prover mecanismos para aplicar diferentes níveis de
refinamento às consultas, segundo critérios preestabelecidos pelos usuários.
Detalhes conceituais e estruturais a respeito dessa linguagem serão discutidos no
próximo capítulo.
30
3. XLPATH: UMA LINGUAGEM PARA NAVEGAÇÃO EM LINKS XML
Este capítulo apresenta a linguagem XLPath, que tem por objetivo permitir
consultas sobre links em documentos XML. Inicialmente, são levantados os
requisitos para essa linguagem. Em seguida, uma formalização para a mesma é
definida e são apontadas as premissas que baseiam suas abordagens, a partir de
uma representação gráfica desenvolvida para os links. Os detalhes sintáticos e
semânticos são discutidos em seção posterior. Finalmente, propõe-se uma
arquitetura para um processador de expressões XLPath.
3.1. REQUISITOS PARA XLPATH
A partir das necessidades verificadas a respeito da navegação sobre links,

bem como das abordagens conceituais de XLink anteriormente discutidas, é
possível compilar uma série de requisitos que orientam a construção de XLPath.
(i) Distinção conceitual entre arcos e ligações, e os elementos que os

definem – Do ponto de vista de XLPath, um arco ou uma ligação devem ser
tomados como o “ato” de um elemento referenciar outro, seja através de um label
(from, to), ou de uma URI (href). Assim sendo, não é incorreto afirmar que, em se
tratando de consultas baseadas nessa linguagem, um arco pode partir de um
elemento locator para um elemento arco, ou vice-versa.
(ii) Navegação em diferentes níveis de abstração – O principal objetivo

de uma linguagem de consulta sobre links é permitir a navegação através da rede
formada pelo referenciamento entre elementos distintos. Contudo, referenciamentos
por URI (href) constituem o único caminho possível entre dois elementos que se
referenciam dessa forma. Assim sendo, XLPath deve prover a opção de abstrair
essas ligações, diminuindo assim a quantidade de passos necessários para se
alcançar o objetivo final da consulta.
(iii) Abordagem para links simples como seus equivalentes

estendidos – No intuito de evitar uma sintaxe demasiado extensa, XLPath deve ser
capaz de navegar sobre links simples com base na mesma sintaxe utilizada para
links estendidos. Para isso, essa linguagem deve partir de uma abordagem que
assimila os links simples enquanto os seus equivalentes estendidos.
31
(iv) Identificação de arcos implícitos – Em situações onde links sejam

declarados sem a ocorrência de arcos, ou que, na ocorrência destes, os atributos
from e/ou to tenham sido omitidos, XLPath deve ser capaz de identificar a ocorrência
de arcos implícitos, mantendo, dessa forma, a conformidade com a especificação de
XLink.
(v) Proximidade com as sintaxes de XPath e XSPath – Assim como

XSPath provê uma sintaxe para navegação sobre esquemas bastante próxima da
sintaxe de XPath, a linguagem aqui proposta para navegação sobre links deve
buscar a máxima proximidade possível com a sintaxe dessas outras linguagens, a
fim de facilitar a assimilação por parte dos usuários.
(vi) Condições para refinamento de consultas – Posto que possa existir

um número arbitrário de links referenciando um dado elemento, XLPath deve
possibilitar que condições de refinamento sejam aplicadas à consulta, a fim de
permitir a distinção entre os diferentes elementos constituintes destes links, a partir
de seus nomes ou valores de atributos.
(vii) Caminho absoluto e relativo, e consulta realizada em passos – Da

mesma forma que ocorre em XPath, XLPath segue o conceito de consulta em
passos, onde cada passo seleciona uma lista de nós que é passada como
parâmetro de entrada para o passo seguinte até a execução do último passo e
obtenção do resultado final. O passo inicial pode partir tanto da raiz de um
documento (caminho absoluto), quanto de um nó específico em seu interior
(caminho relativo).
3.2. UM MODELO DE DADOS PARA XML COM XLINK
Em seu trabalho onde apresentam XPath+, Silva e Times [10] estendem as

definições de Libkin [7] para manipulação de dados XML, visando abranger também
a manipulação de links. Assim, essas definições, válidas para XPath+, por se
tratarem do contexto dos links, podem ser aplicadas também a XLPath.
Definição 1: Uma árvore enraizada, ordenada, rotulada e não classificada é

uma árvore com quantidade ilimitada de número de nós filhos, na qual a cada nó é
dado um único rótulo e, que é um elemento de N* (i.e. uma string finita de números
32
naturais). Então, define-se formalmente uma árvore enraizada, ordenada, rotulada e

não classificada T como um par (D, <pre e) na qual:
(i) a string e (a string vazia) é a raiz;
(ii) D, um grupo de nós chamado de domínio da árvore, é um subconjunto

de N*, tal que e ∈ D, implica w ∈ D, se e somente se w <pre e. A relação <pre é a
relação prefixada com os elementos de D, tal que w <pre e, se e somente se o único
caminho da raiz para e passa por w.
Um documento XML é uma estrutura de dados definida como:
Definição 2: Um documento XML d é representado como uma 5-tupla (T, β,

λ, Rχ, Rσ), na qual:
(i) T = (D, <pre ) é uma árvore enraizada, ordenada, rotulada e não

classificada;
(ii) β é um conjunto de tags (elementos XML);
(iii) λ: D → β é uma função que atribui a cada nó em T uma tag XML;
(iv) Rχ é um conjunto de relações binárias sobre β, presentes em um

mesmo documento XML, tais como parent, child e sibling;
(v) Rσ é um conjunto de relações binárias sobre β´ x β´´, na qual β´ e β´´

são grupos de tags de distintos documentos XML, d´ e d´´, respectivamente, com d´
≠ d´´, d´ ∈ D e d´´ ∈ D.
Para as relações entre nós de um dado documento XML:
Definição 3 (função eixo): Seja d um documento XML (T, β, λ, Rχ, Rσ). Para
uma relação de eixo XLPath χ ⊆ Rχ e ρ(β) como o potencial conjunto de β, define-se
a função fχ: ρ(β)→ P(β) (e então sobrecarrega-se o nome da relação χ, como por
exemplo fchild), com fχ(X) = {y ∈ β | ∃x ∈ X, tal que (x,y) ∈ χ}.
33
Como em XLPath há também relações entre nós de documentos distintos,

tem-se que:
Definição 4: Sendo d´ e d´´ dois documentos XML (T´, β´, λ´, Rχ´, Rσ´) e (T´´,
β´´, λ´´, Rχ´´, Rσ´´), respectivamente. Para uma relação XLPath σ ⊆ Rσ´ em d´, é
definida a função gσ : P(β´)→ P(β´´) com gσ(X) = {y ∈ β´´ | ∃x ∈ X, tal que (x,y) ∈ σ}.
Com base nas definições apresentadas é possível formalizar uma função

capaz de executar expressões XLPath. Sendo ϕ uma expressão de consulta, a
mesma pode ser expressa como ϕ = {(σ(xi) |χ(i)}, onde xi é um elemento definido na
hierarquia de elementos XML, e a consulta pode ser executada sobre a hierarquia
ou sobre links formados por estes elementos. A função NavigationPath [10], cujos
argumentos são uma expressão de consulta e uma lista de nós (node list), é
responsável por fazer uma triagem das consultas, direcionando aquelas que dizem
respeito a links para o processador XLPath, enquanto as demais são redirecionadas
para o processador XPath. O algoritmo para esta função pode ser visto no Quadro 4.
Quadro 4. Algoritmo NavigationPath (Adaptada de [10])
ϕ = {(σ(xi) |χ(i)}
function NavgationPath(ϕ, nodeList)
begin
if ϕ is xpathExpression then
return xpathParser(ϕ, nodeList)
else
return xlpathParser(ϕ, nodeList)
endif
end
3.3. REPRESENTAÇÃO DE LINKS
De acordo com o que foi discutido no capítulo anterior, a linguagem XLink

possibilita a construção de links simples e estendidos, cada um dos quais sendo
compostos por pré-determinados sub-elementos e/ou atributos, podendo estes ser
opcionais ou obrigatórios. Assim sendo, um link pode ser representado graficamente
a partir de uma simbologia para distinção desses componentes. A Tabela 5
apresenta a simbologia utilizada neste trabalho.
34
Tabela 5. Simbologia para Representação de Links
Símbolo Representação Descrição
Elementos cujo atributo type tem valor

Elemento link
“simple” ou “extended”
Elementos referenciados pelo atributo href

Recurso remoto
de um sub-elemento locator
Sub-elementos de links cujo atributo type

Recurso local
tem valor “resource”
Sub-elemento Sub-elementos de links cujo atributo type

arco tem valor “arc”

locator tem valor “locator”

título tem valor “title”
Ligação Referência por URI (href)
Arco Referência por label (from, to)
3.3.1. Representação em baixo nível
Do ponto de vista de XLPath, uma representação em baixo nível é aquela em

que toda a complexidade interna de um link é considerada e todos os itens que o
compõem são representados, dentre os quais recursos remotos e locais, elementos
locator, arco e título, além de atributos e o próprio elemento link.
O Quadro 5 traz um link estendido que representa uma grade curricular onde
há exemplos de todos os itens citados: três recursos, sendo um local e dois remotos
(com seus respectivos locators), dois arcos e um título. Além disso, cada elemento
possui diversos atributos.
35
Quadro 5. Link Estendido Grade Curricular
<gradeCurricular
xmlns:xlink=”http://www.w3.org/1999/xlink”
xlink:type=”extended”>
<titulo
xlink:type=”title”>Grade Curricular de Aristóteles</titulo>
<aluno
xlink:type=”locator”
xlink:href=” http://www.exemplo.com/alunos#aristoteles”
xlink:label=”aluno15”
xlink:title=”Aristóteles”/>
<curso
xlink:href=” http://www.exemplo.com/cursos#hf-02”
xlink:label=”curso02”
xlink:title=”História da Filosofia II”/>
<cr
xlink:type=”resource”
xlink:label=”aluno15CR”>7.0</cr>
<go
xlink:type=”arc”
xlink:from=”aluno15”
xlink:to=”aluno15CR”
xlink:title=”Coeficiente de Rendimento de Aristóteles”/>
<go
xlink:from=”curso02”
xlink:to=”aluno15”
xlink:arcrole=”http://www.exemplo.com/arcrole/matriculado”
xlink:title=”Aristóteles matriculado no curso”/>
</ gradeCurricular >
A Figura 5 mostra a representação em baixo nível do link em questão, com

base na simbologia anteriormente apresentada. Para melhor visualização, somente
foram representados os atributos mais relevantes no que tange às ligações e arcos,
ou seja, aqueles que exercem função de referenciamento: href, from e to. O rótulo
dos símbolos consiste no valor do atributo label do elemento representado, ou,
quando este não possui label, no nome do próprio elemento. Para diferenciá-los, os
elementos arco recebem um numeral em sobrescrito.
36
Linkbase Instância
gradeCurricular
href
to from
go1 href
aristoteles
aluno15CR
aluno15
to
href
go2
href
titulo curso02
hf-02
from
href
Figura 5. Link Estendido em Abordagem de Baixo Nível
A linha tracejada foi utilizada para distinguir os diferentes documentos

envolvidos, i.e. a instância, onde estão localizados os recursos remotos, e o
linkbase, onde se encontra o link estendido. Outro detalhe importante são as
ligações com terminação tracejada que se conectam aos recursos remotos. Essas
ligações representam o referenciamento feito por outros links a estes recursos. Vale
lembrar que um dado recurso pode ser referenciado por um número arbitrário de
links.
3.3.2. Representação em alto nível
Um elemento do tipo locator tem a função de ser a representação local de um

dado recurso remoto. Por conta disso, para cada recurso remoto haverá apenas um
único locator como sub-elemento do link o referenciando. Assim sendo, sempre que
o elemento locator ou algum dos seus atributos não forem o objetivo final de uma
consulta, é interessante que a linguagem de navegação abstraia a referência entre
locators e recursos remotos, já que há um único caminho possível para navegação
entre eles.
Para que isso seja possível, XLPath provê uma abordagem em alto nível,
onde o referenciamento por meio de locators é abstraído, e os arcos passam a
37
referenciar diretamente os recursos remotos. Uma representação em alto nível para

o link da Grade Curricular pode ser vista na Figura 6. Analogamente ao ocorrido em
baixo nível, aqui os arcos com terminação tracejada são aqueles provenientes de
outros links, segundo a abordagem em alto nível.
Linkbase Instância
to
gradeCurricular
from
to aristoteles
go1
aluno15CR to
to
titulo go2
hf-02
from
from
Figura 6. Link Estendido em Abordagem de Alto Nível
3.4. ABORDAGEM PARA LINKS SIMPLES
No capítulo 2, os links simples foram apresentados como a forma de se

reproduzir em XML as mesmas funcionalidades dos links HTML, sem lançar mão da
complexidade dos links estendidos. É possível, no entanto, alcançar essas mesmas
funcionalidades através de um link estendido. Portanto, é correto afirmar que para
cada link simples existe um equivalente estendido [21].
Com base nisso, para manter a consistência sintática sem prejuízo semântico,
XLPath provê uma abordagem para links simples a partir de seus equivalentes
estendidos. Em outras palavras, no momento do processamento de uma consulta, o
processador XLPath assimila os links simples como sendo seus equivalentes
estendidos, permitindo dessa forma que a consulta alcance os componentes destes
links a partir da mesma sintaxe utilizada para os links estendidos. O Quadro 6
38
mostra o equivalente estendido do link simples: <alunoLink xlink:type=”simple”

xlink:href=” http://www.exemplo.com/alunos#aristoteles”>Aristóteles</alunoLink>.
Quadro 6. Equivalente Estendido de um Link Simples
<alunoLink
xmlns:xlink=”http://www.w3.org/1999/xlink”
xlink:type=”extended”>
<resource
xlink:type=”resource”
xlink:label=”local”>Aristóteles</resource>
<locator
xlink:href=”…”
xlink:label=”remote”/>
<go
xlink:from=”local”
xlink:to=”remote”/>
</ alunoLink >
3.5. ABORDAGEM PARA LINKS COM ARCOS IMPLÍCITOS
Segundo a especificação de XLink, um arco é todo elemento que contém o

atributo type, do namespace de XLink, com o valor “arc”. Além disso, para que
tenham significado dentro do contexto de XLink, esses elementos devem ser
declarados como filhos de links estendidos [21]. A finalidade de um arco é
estabelecer um relacionamento entre um par de recursos, sendo que esse
relacionamento sempre tem um sentido definido. Uma das formas de defini-lo é
declarar valores para os atributos globais from e to: o arco parte do recurso
referenciado pelo from no sentido do recurso referenciado pelo to.
Entretanto, segundo o que foi apresentado na Tabela 1, capítulo 2, esses

atributos não são obrigatórios, sendo possível, desse modo, que arcos sejam
declarados sem que haja um referenciamento de partida (from) e/ou de destino (to).
Nesses casos, a especificação de XLink considera a ocorrência de arcos

implícitos – já que, em verdade, esses arcos não existem no código – referenciando
cada locator do link em questão, através do(s) atributo(s) omitido(s). Por exemplo,
em um link que possua cinco locators, caso haja um arco cujo atributo from tenha
sido omitido, esse arco é equivalente a cinco arcos implícitos, cada um deles
39
referenciando um dos locators através de um respectivo from. Uma interpretação

análoga deve ser assimilada para os casos de omissão do atributo to. Havendo a
omissão de ambos os atributos, será considerada a ocorrência de arcos implícitos
para cada possível combinação de referenciamento a elementos do tipo locator no
contexto do link.
Além disso, outra possibilidade é a ocorrência de links para os quais nenhum

arco tenha sido declarado. Conforme o que foi discutido no capítulo 2, a
especificação de XLink não obriga que links contenham arcos. Nesses casos, a
interpretação deve ser a similar à ocorrência de um único arco cujos atributos from e
to tenham sido omitidos.
No intuito de manter a conformidade com a especificação de XLink, porém

sem prejuízo da consistência sintático-semântica, para situações onde links sejam
declarados sem a ocorrência de arcos, ou que, na ocorrência destes, seja verificada
a omissão dos atributos from e/ou to, XLPath provê uma abordagem considerando a
existência de arcos implícitos. Assim, no momento da execução de uma consulta,
um processador XLPath deve gerar na memória uma representação para cada arco
implícito, permitindo que os dados sejam acessados com base na mesma sintaxe
utilizada para os arcos explícitos. Contudo, é importante frisar que todo esse
processo se dará de forma transparente para o usuário.
3.6. SINTAXE E SEMÂNTICA
Nesta seção, serão discutidos os principais aspectos que constituem a sintaxe

de XLPath, bem como a semântica que ela representa.
A princípio, o bloco básico que permite a formulação de consultas em XLPath,

assim como em outras linguagens path como XPath e XSPath, é a expressão.
Expressões são composições estruturadas de mecanismos que permitem a seleção
de nós, sob critérios pré-determinados, em um documento XML. Além disso,
expressões consistem de um ou mais passos, que podem ser combinados em
sequências, onde o resultado da execução de cada um deles alimenta o passo
seguinte, até que o último seja executado e o resultado final obtido. Em XLPath, um
40
passo é formado pela sequência: especificação de eixo, especificação de elemento,

e predicado, sendo que este último é opcional.
3.6.1. Especificação de eixo
Nas demais linguagens path citadas, a especificação de eixo se baseia,

principalmente, nos relacionamentos implícitos à hierarquia formada pela
estruturação de XML. Como visto, essa estruturação é caracterizada por formar uma
árvore. Dessa maneira, um eixo é o mecanismo que define os nós que serão
selecionados, com base no relacionamento que configuram para com o nó de
contexto. Em uma árvore XML, os possíveis relacionamentos são: ancestral, pai,
descendente, filho, irmão, entre outros.
Entretanto, do ponto de vista da composição de um link, há um tipo singular

de relacionamento: o referenciamento. Como não há restrições sobre quais
elementos podem ser referenciados ou, ainda, sobre a quantidade de
referenciamentos, a estruturação resultante, diferentemente das árvores dos
esquemas e instâncias, se assemelha a uma rede. O objetivo de XLPath é, acima de
tudo, possibilitar a navegação através dessa rede, uma vez que a navegação
através da estrutura em árvore já é suportada por linguagens como XPath (em
instâncias) e XSPath (em esquemas). Por conta disso, os principais eixos providos
por XLPath têm a função de definir os nós que serão selecionados segundo o tipo de
referenciamento existente entre eles e o nó de contexto. Estes eixos incluem:
• Eixo linked – Seleciona todos os elementos que referenciam o nó de

contexto, seja por URI (href), ou através de um label (from, to);
• Eixo arc-source – Seleciona os elementos que são o destino de arcos

cuja origem é o nó de contexto;
• Eixo arc-destination – Seleciona os elementos que são a origem de

arcos cujo destino é o nó de contexto;
Além destes, XLPath provê eixos para localizar elementos participantes de

links a partir de um nó de contexto que não está sendo referenciado por eles. Estes
eixos têm a função de permitir consultas de caminho absoluto (aquelas que partem
41
da raiz do documento) ou para encontrar links dentro do contexto de um dado

elemento XML. São eles:
• Eixo link-part-descendant – Seleciona os elementos descendentes do

nó de contexto que são participantes de links, i.e. elementos que referenciam ou são
referenciados por outros elementos;
• Eixo link-part-child – Seleciona os elementos filhos do nó de contexto

que são participantes de links;
Conforme fora discutido, do ponto de vista de XLPath há dois níveis de

abstração distintos: baixo nível e alto nível. Analogamente à sintaxe de XSPath, aqui
o nível a ser utilizado por um passo deve ser especificado a partir de um prefixo
aplicado a um eixo, sendo: (i) LL para baixo nível (low level); ou (ii) HL para alto nível
(high level).
Para exemplificar a utilização dos eixos, a Tabela 6 mostra o resultado da

aplicação de alguns deles em elementos do link Grade Curricular (as ligações com
outros links foram desconsideradas neste exemplo).
Tabela 6. Especificação de Eixo em XLPath
Nó de Contexto Especificação de eixo Nós identificados
aluno15 LL::linked go1, go2, aristoteles
go1 HL::linked aristoteles, aluno15CR
hf-02 LL::arc-source
hf-02 HL::arc-source go2
aluno15CR LL::arc-destination go1
titulo HL::arc-destination
3.6.2. Especificação de elemento
A seleção efetuada por um eixo não leva em conta o tipo do elemento que
está referenciando ou sendo referenciado pelo nó de contexto, mas apenas se há ou
não um referenciamento. Além disso, ainda que os elementos selecionados sejam
42
todos do mesmo tipo, dispondo apenas dos eixos não é possível diferenciá-los
segundo algum critério.
A especificação de elemento permite filtrar os elementos selecionados por um

eixo a partir de seus tipos, havendo ainda a opção de incrementar o refinamento
através de seus nomes. XLPath disponibiliza as seguintes opções de especificação
de elemento:
• locator(elementName) – Seleciona elementos do tipo locator cujo nome

é aquele fornecido (opcional) como parâmetro;
• arc(elementName) – Seleciona elementos do tipo arc cujo nome é

aquele fornecido (opcional) como parâmetro;
• resource(elementName) – Seleciona elementos do tipo resource cujo

nome é aquele fornecido (opcional) como parâmetro;
• remote(elementName) – Seleciona recursos remotos cujo nome é

aquele fornecido (opcional) como parâmetro;
• element(elementName) – Seleciona qualquer tipo de elemento cujo

nome é aquele fornecido (opcional) como parâmetro;
A Tabela 7 mostra o resultado da especificação de elemento quando aplicada

a diferentes elementos extraídos do link Grade Curricular.
3.6.3. Predicado
Mesmo aplicando a especificação de elemento é possível que haja elementos

do mesmo tipo e com o mesmo nome, como no caso da aplicação de arc(go), no
exemplo da Tabela 7.
Em situações como esta, para se refinar ainda mais uma consulta, XLPath
provê a opção de se aplicar um predicado, que consiste em um operador para testar
características do nó de contexto, como atributos, conteúdo texto, ou o nome do link
do qual ele faz parte. O operador é testado em cada nó resultante da especificação
de elemento como uma função booleana: quando o resultado é verdadeiro, o nó é
43
mantido na lista, caso contrário o mesmo é deletado. A sintaxe para esses

operadores tem as seguintes formas:
• attribute(attributeName)=”attributeValue”, onde attributeName é o nome

do atributo a ser testado, que deve ser passado como parâmetro, cujo valor será
comparado ao attributeValue;
• text()=”textValue”, onde o conteúdo texto do elemento será comparado

ao textValue.
• link(linkName), onde será testado se o nó de contexto é parte de um

link com o nome linkName.
Tabela 7. Especificação de Elemento em XLPath
Nó de Contexto Especificação de elemento Nós identificados
aluno15 aluno15
locator(aluno15)
curso02
go1 go1
arc(go)
go2 go2
aristoteles
resource() aluno15CR
aluno15CR
aristoteles
remote() aristoteles
aluno15CR
aluno15CR aluno15CR
go2 element() go2
aluno15 aluno15
A Tabela 8 mostra o resultado do refinamento através de predicados

aplicados ao exemplo da Tabela 7. Neste exemplo, o operador link(linkName)
permite especificar o link sobre o qual a navegação deve ocorrer, considerando-se a
ocorrência de referenciamentos por mais de um link. Estes referenciamentos são
representados pelos elementos locator1 e locator2.
44
Tabela 8. Predicados em XLPath
Nó de Nós
Especificação de elemento com Predicado
Contexto identificados
go1
2
arc(go)[attribute(from)=”aluno15”] go1
go
go1 arc(go)[attribute(arcrole)=
2
go2
go ”http://www.exemplo.com/arcrole/matriculado”]
aluno15CR
go2 element()[text()=”7.0”] aluno15CR
aluno15
aluno15
curso02 aluno15
locator()[link(gradeCurricular)]
locator1 curso02
locator2
Assim sendo, a forma geral de um passo de expressão XLPath contendo os

mecanismos apresentados tem o seguinte aspecto:
level::axis::element(elementName*)[operator(operatorName*)=”operatorValue”]*
Onde * indica que o item é opcional. O Quadro 7 apresenta formalização completa

dessa sintaxe com base na notação EBNF [5].
Quadro 7. Notação EBNF para XLPath

XLPathExpr ::= AbsLocationPath | RelLocationPath
AbsLocationPath ::= “/” RelLocationPath
RelLocationPath ::= Step | RelLocationPath “/” Step
Step ::= LevelSpec AxisSpec ElementSpec Predicate*
LevelSpec ::= (“HL” | “LL”) “::”
AxisSpec ::= (“arc-destination” | “arc-source” | “linked” |
“link-part-child” | “link-part-descendant”) “::”
ElementSpec ::= ElementName “(” QName? “)”
ElementName ::= “arc” | “element” | “locator” | “remote” | “resource”
Predicate ::= “[” Operator Spec“]”
OperatorSpec ::= AttributeSpec | LinkSpec | TextSpec
AttributeSpec ::= “attribute(” QName “)=” Value
LinkSpec ::= “link(” QName “)”
TextSpec ::= “text()=” Value
45
3.7. ARQUITETURA DE UM PROCESSADOR XLPATH
Esta seção apresenta a arquitetura de um processador de consultas XLPath,

baseado no padrão MVC (Model-View-Controller) [12]. Esse padrão tem como
característica a subdivisão do software em três camadas de funcionalidade: o
modelo (model) se encarrega da manutenção dos dados; a visão (view) é
responsável pela entrada e apresentação dos dados ao usuário; e, por fim, o
controlador (controller) define as regras do negócio.
No processador XLPath, a visão é formada pelos componentes Console, que

provê ao usuário uma interface para entrada de expressões e documentos para
consulta, bem como a apresentação dos resultados obtidos; e Formatter, que
formata estes resultados para melhor visualização por parte do usuário.
A camada de modelagem possui os componentes Expression, Step e Element

Store. Estes primeiros são responsáveis por manter as expressões de consulta e
suas respectivas subdivisões em passos, que serão processados sequencialmente.
A armazenagem dos elementos resultantes do processamento dos passos é função
do Element Store.
Por fim, o controlador é composto pelos módulos Executor e Processor. O

Executor cria instâncias correspondentes às expressões de consulta fornecidas pelo
usuário, e gera uma representação na memória dos documentos de entrada. Essa
representação é gerada com base na tecnologia DOM (Docment Object Model) [16],
uma API criada pelo W3C para permitir o acesso dinâmico ao conteúdo de
documentos HTML e XML. Em seguida, a expressão instanciada e a representação
lógica do documento são passadas como parâmetro ao Processor, que processa a
consulta e retorna um objeto da classe Element Store contendo o resultado. Ao final,
este resultado é formatado e apresentado ao usuário. A Figura 7 traz uma
representação do processador XLPath contendo os componentes aqui descritos.
46
Element
Formatter Processor Store
DOM
Result
Console Executor Expression Step
Query
and
Document View Controller Model
s
Figura 7. Arquitetura de um Processador XLPath
3.8. CONCLUSÃO
A sintaxe criada para XLPath atende ao requisito de proximidade com XPath,

uma vez que ambas compartilham da mesma estrutura básica: uma especificação
de eixo, seguida de uma especificação de elemento, e um, opcional, predicado.
Além desses, há ainda o mecanismo de especificação de nível de abstração,
inspirado em XSPath. Assim sendo, essa linguagem permite que usuários já
habituados às consultas em XPath e/ou XSPath necessitem de um menor esforço no
sentido de assimilarem a sua sintaxe.
No intuito de comprovar a eficiência dessa sintaxe para navegação sobre

links, foi desenvolvido um protótipo de processador para XLPath, com base na
arquitetura definida na seção 3.7. O próximo capítulo é destinado à apresentação
desse protótipo, bem como dos resultados com ele alcançados na execução de
consultas XLPath.
47
4. ESTUDO DE CASO
Este capítulo é destinado a demonstrar o funcionamento de XLPath, através

da apresentação de um protótipo de processador para essa linguagem e o seu
desempenho na execução de consultas sobre links.
4.1. PROTÓTIPO DE UM PROCESSADOR XLPATH
O protótipo aqui apresentado foi desenvolvido em linguagem Java [11],

tomando como base a arquitetura definida no capítulo 3. Cada componente dessa
arquitetura foi modelado em uma classe Java, e essas classes foram agrupadas em
pacotes denominados model, view e controller, correspondentes à abordagem MVC.
A Figura 8 mostra a tela de entrada e saída de dados provida pela classe
XLPathConsole.
Figura 8. Console do Processador XLPath
Assim como mostram as inscrições em sua tela inicial, essa versão do

protótipo não suporta a navegação através de múltiplos documentos. Dessa forma,
as consultas se restringem a links e instâncias contidos em um mesmo documento
XML.
48
Por conta disso, para a realização dos testes foi utilizado o documento
escola_de_filosofia.xml, que contém o link Grade Curricular apresentado no Quadro
5. Além deste, esse documento é composto por outro link estendido de mesmo
nome. Os recursos remotos (nesse caso, elementos XML representando indivíduos
e cursos acadêmicos) referenciados por esses links também se encontram neste
mesmo documento.
A Figura 9 mostra os resultados sendo apresentados no console do protótipo

após a submissão de uma consulta. A saída é organizada pela classe
XLPathFormatter, que mostra a sequência de passos da expressão XLPath
submetida e os respectivos elementos resultantes de seu processamento pela
classe XLPathProcessor.
Figura 9. Resultados no Console XLPath
Neste exemplo, a expressão XLPath submetida foi composta por nove

passos, de modo a combinar abordagens em baixo e alto nível, e, em alguns casos,
fazendo uso de operadores de predicado para refinar a consulta. Dessa forma,
puderam ser testados todos os mecanismos providos por XLPath: as especificações
de nível de abstração, de eixo e de elemento, e os operadores de predicado. O
Quadro 8 mostra o resultado completo da consulta XLPath extraído do console.
49
Quadro 8. Saída do Processador XLPath

---------------- XLPath Result ----------------
Step (1): /aristoteles::LL::linked::element()
Locators = {aluno}
Arcs = {}
Resources = {}
Remotes = {}
Step (2): /LL::linked::arc(go)[attribute(role)='matricula']
Locators = {}
Arcs = {go}
Resources = {}
Remotes = {}
Step (3): /HL::arc-source::remote()
Locators = {}
Arcs = {}
Resources = {}
Remotes = {historiaFilosofia2}
Step (4): /HL::arc-source::arc()
Locators = {}
Arcs = {go, go}
Resources = {}
Remotes = {}
Locators = {}
Arcs = {}
Resources = {}
Remotes = {platao}
Step (6): /HL::arc-source::arc()[attribute(role)='matricula']
Locators = {}
Arcs = {go}
Resources = {}
Remotes = {}
50
Step (7): /HL::linked::remote(introducaoFilosofia)
Locators = {}
Arcs = {}
Resources = {}
Remotes = {introducaoFilosofia}
Step (8): /HL::arc-source::element()
Locators = {}
Arcs = {go, go}
Resources = {}
Remotes = {}
Locators = {}
Arcs = {}
Resources = {}
Remotes = {socrates}
4.2. CONCLUSÃO
O documento submetido ao protótipo do processador XLPath é uma pequena

representação de uma escola de filosofia, que contém links estendidos
representando as grades curriculares dos alunos. Em um desses links, os indivíduos
Aristóteles e Platão compõem uma relação de aluno e professor, respectivamente,
através do referenciamento ao curso História da Filosofia II. Além disso, em um
segundo link, o mesmo Platão compõe outra relação desse tipo com o indivíduo
Sócrates, porém dessa vez no papel de aluno do curso Introdução à Filosofia, do
qual Sócrates é referenciado como professor.
Na consulta realizada, a navegação teve início no elemento correspondente

ao indivíduo Aristóteles, passando por todos os relacionamentos mencionados, até
ser alcançado o elemento correspondente ao indivíduo Sócrates. Este é um exemplo
de como grande parte da semântica de uma estruturação XML pode ser atribuída
aos links, e de como a linguagem XLPath pode ser utilizada para explorá-la.
51
O código completo do documento XML utilizado neste exemplo, bem como

das classes Java desenvolvidas para o protótipo, encontram-se disponíveis nos
Apêndices deste trabalho, disposto na seguinte ordem:
• Apêndice A, escola_de_filosofia.xml;
• Apêndice B, XLPathConsole.java;
• Apêndice C, XLPathFormatter.java;
• Apêndice D, XLPathExpression.java;
• Apêndice E, XLPathStep.java;
• Apêndice F, XLPathElementStore.java;
• Apêndice G, XLPathExecutor.java;
• Apêndice H, XLPathProcessor.java.
No próximo capítulo serão apresentadas as conclusões finais a respeito deste

trabalho, destacando os pontos mais importantes no seu desenvolvimento. Além
disso, serão apontadas propostas para trabalhos futuros, no intuito de dar
continuidade a este projeto.
52
5. CONCLUSÃO
A linguagem para navegação sobre links proposta neste trabalho se

caracteriza como uma verdadeira linguagem path, permitindo que consultas sejam
realizadas em passos, de modo que os “caminhos” formados entre os elementos
que compõem os links sejam percorridos, e esses elementos acessados. Além
disso, a linguagem provê mecanismos para que sejam estabelecidos critérios,
segundo os quais se dará a navegação, permitindo assim que usuários e/ou
aplicações alcancem, com precisão, elementos específicos dentro da rede de
referenciamentos característica dos links.
Isso foi possível graças à combinação de diferentes mecanismos, como a

especificação de nível de abstração e os operadores de predicado, ambos
inspirados em XSPath. Este primeiro permite que o usuário realize consultas mais
simplificadas ou mais especializadas, a depender de seus objetivos. Já os
operadores de predicado constituem poderosos instrumentos para refinamento das
consultas, selecionando elementos com base nos valores de seus atributos ou de
seu conteúdo texto, por exemplo. Além disso, XLPath faz uso de eixos que, dentre
outros, orientam a navegação segundo a condição do nó de contexto, enquanto
origem ou destino de arcos. Essa semântica se baseia nos eixos provenientes da
linguagem XPath+.
Em XLPath, os mecanismos mencionados são utilizados para compor

expressões de navegação, cujo arranjo é similar às expressões location path, de
XPath. Dessa forma, a assimilação de sua sintaxe é facilitada, sobretudo para
aqueles usuários já habituados com XPath. A eficácia dessa sintaxe pôde ser
comprovada através do estudo de caso apresentado neste trabalho, onde o protótipo
de processador XLPath desenvolvido foi utilizado para explorar um documento XML
contendo links de XLink.
No intuito de dar continuidade a este projeto, pretende-se desenvolver uma

nova versão para o processador XLPath, que permita a navegação através de links
que referenciam recursos contidos em documentos XML distintos.
53
REFERÊNCIAS
[1] BERNERS-LEE, T. et al. Uniform Resource Identifiers (URI): generic syntax

(1998).
[2] CAVALIERI, Federico; GUERRINI, Giovanna; MESITI, Marco. Navigation

Path Expressions on XML Schema. Turin: 19th International Conference on
Database and Expert Systems Applications – DEXA, 2008.
[3] COVER, Robin. SGML: general introductions and overviews. Disponível em:
<http://xml.coverpages.org/general.html>. Acesso em: junho 2010.
[4] DEITEL, Harvey M. et al. XML: how to program. New Jersey: Prentice Hall,
2000. 934 p.
[5] GARSHOL, Lars Marius. BNF and EBNF: what are they and how do they
work?. Disponível em: <http://www.garshol.priv.no/download/text/bnf.html>.
Acesso em: junho 2010.
[6] HAROLD, Elliotte Husty; MEANS, W. Scott. XML In a Nutshell: a desktop

quick reference. 2 Ed. O’Reilly Media, 2002. 640 p.
[7] LIBKIN, Leonid. Logics For Unrankered Trees: an overview. Logical Methods
in Computer Science 2, 2006.
[8] LOWE, David; WILDE, Erik. Improving Web Linking Using XLink. Sydney:
University of Technology, 2001.
[9] NFE. Portal Nacional da Nota Fiscal Eletrônica. Disponível em:

<http://www.nfe.fazenda.gov.br/portal/>. Acesso em: junho 2010.
[10] SILVA, P. C., TIMES, V. C. XPath+: a tool for linked XML documents
navigation. Lyon: XSym 2009 - Sixth International XML Database Symposium,
2009.
[11] SUN MICROSYSTEMS. About Java Technology. Disponível em:

<http://www.sun.com/java/about/>. Acesso em: junho 2010.
[12] SUN MICROSYSTEMS. Java BluePrints Model-View-Controller. Disponível

em: <http://java.sun.com/blueprints/patterns/MVC-detailed.html>. Acesso em:
junho 2010.
[13] W3 SCHOOLS. DTD Tutorial. Disponível em:

<http://www.w3schools.com/dtd/>. Acesso em: junho 2010.
[14] W3 SCHOOLS. XML Schema ComplexType Element. Disponível em:

<http://www.w3schools.com/Schema/el_complextype.asp>. Acesso em: junho
2010.
54
[15] W3 SCHOOLS. XPath: tutorial which covers syntax, locations, expressions,

functions and examples. Disponível em: <www.w3schools.com/xpath/>.
[16] W3C. Document Object Model (DOM). Disponível em:

<http://www.w3.org/DOM/>. Acesso em: junho 2010.
[17] W3C. Extensible Markup Language (XML) 1.0 (Fifith Edition). W3C
Recommendation (2008). Disponível em: <http://www.w3.org/TR/REC-xml/>.
[18] W3C. HTML 4.01 Specification. W3C Recommendation (1999). Disponível

em: <http://www.w3.org/TR/1999/REC-html401-19991224/>. Acesso em:
junho 2010.
[19] W3C. Namespaces in XML 1.0 (Third Edition). W3C Recommendation

(2009). Disponível em: <http://www.w3.org/TR/REC-xml-names/>. Acesso em:
junho 2010.
[20] W3C. World Wide Web Consortium: about W3C. Disponível em:
<http://www.w3.org/Consortium/ >. Acesso em: junho 2010.
[21] W3C. XML Linking Language (XLink) Version 1.0. W3C Recommendation
(2001). Disponível em: <http://www.w3.org/TR/xlink/>. Acesso em: junho 2010.
[22] W3C. XML Path Language (XPath) Version 1.0. W3C Recommendation
(1999). Disponível em: <http://www.w3.org/TR/xpath/>. Acesso em: junho
2010.
[23] W3C. XML Pointer Language (XPointer) Version 1.0. W3C Last Call
Working Draft (2001). Disponível em: <http://www.w3.org/TR/2001/WD-xptr-
20010108/>. Acesso em: junho 2010.
[24] W3C. XML Schema Part 1: structures second edition. W3C Recommendation
(2004). Disponível em: <http://www.w3.org/TR/xmlschema-1/>. Acesso em:
junho 2010.
[25] W3C. XQuery 1.0: an XML query language. W3C Recommendation (2007).
Disponível em: <http://www.w3.org/TR/xquery/>. Acesso em: junho 2010.
[26] W3C. XSL Transformations (XSLT) Version 1.0. W3C Recommendation

(1999). Disponível em: <http://www.w3.org/TR/xslt>. Acesso em: junho 2010.
[27] WIKIPEDIA. Structured Query Language. Disponível em:

<http://en.wikipedia.org/wiki/SQL>. Acesso em junho 2010.
55
APÊNDICE A – escola_de_filosofia.xml
Documento que contém a estrutura XML utilizada no estudo de caso do

capítulo 4.
<?xml version="1.0" encoding="UTF-8"?>
<escolaFilosofia id="bookStore" xmlns:xlink="http://www.w3.org/1999/xlink">

<aristoteles id="aristoteles">
<idade>25</idade>
<matricula>123</matricula>
</aristoteles>
<platao id="platao">
<idade>52</idade>
</platao>
<socrates id="socrates">
<idade>64</idade>
</socrates>
<historiaFilosofia2 id="hf-02">
<horas>80</horas>
</historiaFilosofia2>
<introducaoFilosofia id="if">
<horas>75</horas>
</introducaoFilosofia>
<gradeCurricular xmlns:xlink="http://www.w3.org/1999/xlink"
xlink:type="extended">
<titulo xlink:type="title">Grade Curricular de Aristóteles</titulo>
<aluno xlink:type="locator" xlink:href="instancia.xml#aristoteles"

xlink:label="aluno15" xlink:title="Aristóteles"/>
<professor xlink:type="locator" xlink:href="instancia.xml#platao"

xlink:label="professor02" xlink:title="Platão"/>
<curso xlink:type="locator" xlink:href="instancia.xml#hf-02"

xlink:label="curso02" xlink:title="História da Filosofia II"/>
<cr xlink:type="resource" xlink:label="aluno15CR">7.0</cr>
<go xlink:type="arc" xlink:from="aluno15" xlink:to="aluno15CR"

xlink:title="Coeficiente de Rendimento de Aristóteles" />
<go xlink:type="arc" xlink:from="curso02" xlink:to="aluno15"

56
xlink:arcrole="http://www.exemplo.com/arcrole/matriculado"
xlink:title="Aristóteles matriculado no curso"
xlink:role="matricula" />
<go xlink:type="arc" xlink:from="professor02" xlink:to="curso02"

xlink:arcrole="http://www.exemplo.com/arcrole/professor"
xlink:title="Platão professor da disciplina" />
</gradeCurricular>
<gradeCurricular xmlns:xlink="http://www.w3.org/1999/xlink"
xlink:type="extended">
<titulo xlink:type="title">Grade Curricular de Platão</titulo>
<aluno xlink:type="locator" xlink:href="instancia.xml#platao"

xlink:label="aluno07" xlink:title="Platão"/>
<professor xlink:type="locator" xlink:href="instancia.xml#socrates"

xlink:label="professor01" xlink:title="Sócrates"/>
<curso xlink:type="locator" xlink:href="instancia.xml#if"

xlink:label="curso05" xlink:title="Introdução à Filosofia"/>
<cr xlink:type="resource" xlink:label="aluno07CR">8.6</cr>
<go xlink:type="arc" xlink:from="aluno07" xlink:to="aluno07CR"

xlink:title="Coeficiente de Rendimento de Platão" />
<go xlink:type="arc" xlink:from="curso05" xlink:to="aluno07"

xlink:arcrole="http://www.exemplo.com/arcrole/matriculado"
xlink:title="Platão matriculado no curso"
xlink:role="matricula" />
<go xlink:type="arc" xlink:from="professor01" xlink:to="curso05"

xlink:arcrole="http://www.exemplo.com/arcrole/professor"
xlink:title="Sócrates professor da disciplina" />
</gradeCurricular>
</escolaFilosofia>
57
APÊNDICE B - XLPathConsole.java
Código Java da classe XLPathConsole, que compõe o protótipo apresentado

no capítulo 4.
package xlpath.view;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.UIManager;
import javax.swing.border.EtchedBorder;
import xlpath.controller.XLPathExecutor;
import xlpath.model.XLPathExpression;
public class XLPathConsole extends JFrame{
private static final long serialVersionUID = 1L;
private JTextField jExpression = new JTextField();

private JTextField jFile = new JTextField();
private JLabel lNameApp = new JLabel();
private JLabel lExpression = new JLabel();
private JLabel lFile = new JLabel();
private JButton bSubmit = new JButton();
private JTextArea tResult = new JTextArea();
private JScrollPane spResult = new JScrollPane();
private JFileChooser jTreeFile = new JFileChooser();
private JButton bFile = new JButton();
public XLPathConsole(){
try {
makeWindow();
58
} catch (Exception e) {
e.printStackTrace();
}
}
public void makeWindow(){

this.getContentPane().setLayout( null );
this.setSize(new Dimension(900, 500));
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = this.getSize();
if (frameSize.height > screenSize.height){

frameSize.height = screenSize.height;
}
if (frameSize.width > screenSize.width){
frameSize.width = screenSize.width;
}
this.setLocation( ( screenSize.width - frameSize.width ) / 2, ( screenSize.height - frameSize.height

) / 2 );
this.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
this.setTitle( "XLPath Query Processor" );
this.addWindowListener(new WindowAdapter() {
public void windowOpened(WindowEvent we) {
windowIsOpened(we);
}
});
lNameApp.setText(".: XLPath :.");

lNameApp.setBounds(new Rectangle(20, 0, 900, 20));
lNameApp.setFont(new Font("Dialog", 1, 12));
lExpression.setText("Expression: ");
lExpression.setBounds(new Rectangle(20, 20, 200, 20));
lExpression.setFont(new Font("Dialog", 1, 11));
jExpression.setBounds(new Rectangle(20, 40, 400, 20));
jFile.setBounds(new Rectangle(480, 40, 200, 20));
lFile.setText("File: ");
lFile.setBounds(new Rectangle(480, 20, 150, 20));
lFile.setFont(new Font("Dialog", 1, 11));
bFile.setText("...");
bFile.setBounds(new Rectangle(685, 40, 20, 20));
bFile.setFont(new Font("Dialog", 1, 11));
bFile.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
chooseFile(ae);
}
59
});
bSubmit.setText("Enviar");
bSubmit.setBounds(new Rectangle(740, 40, 80, 20));
bSubmit.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
execute(ae);
}
});
spResult.setBounds(new Rectangle(20, 75, 800, 360));
spResult.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.LOWERED));
tResult.setEditable(false);
tResult.setWrapStyleWord(true);
tResult.setLineWrap(true);
String inicialMessage = "XLPath Query Processor - Versão 1.0\n\nInstruções:\n\n" +
"(1) - Insira uma expressão XLPath\n" +
"(2) - Selecione um arquivo XML\n" +
"(3) - Clique 'Enviar'" +
"\n\n\nLimitações:\n\n" +
"Esta versão não suporta navegação em múltiplos
documentos." +
"\n\n\nDesenvolvido por:\n\n" +
"Marcelo Mendonça -
mendonca.area1@gmail.com\n" +
"Jader do Monte -
jader_do_monte@hotmail.com";
tResult.setText(inicialMessage);
spResult.getViewport().add(tResult, null);
this.getContentPane().add(lNameApp, null);
this.getContentPane().add(jExpression, null);
this.getContentPane().add(lExpression, null);
this.getContentPane().add(lFile, null);
this.getContentPane().add(jFile, null);
this.getContentPane().add(bSubmit, null);
this.getContentPane().add(spResult, null);
this.getContentPane().add(bFile, null);
}
private void windowIsOpened(WindowEvent e) {

jExpression.requestFocus();
}
private void chooseFile(ActionEvent ae){

jTreeFile.setDialogTitle("Select a File (.xml, .xsd)");
int returnVal = jTreeFile.showOpenDialog(XLPathConsole.this);
if(returnVal == JFileChooser.APPROVE_OPTION){
File file = jTreeFile.getSelectedFile();
60
jFile.setText(file.getAbsolutePath());
}
}
private void execute(ActionEvent ae){

if(!jExpression.getText().equals("")){
if(!jFile.getText().equals("")){
XLPathExpression expression = new
XLPathExpression(jExpression.getText());
if(expression.makeSteps()){
XLPathExecutor executor = new XLPathExecutor(expression,
jFile.getText());
XLPathFormatter formatter = new
XLPathFormatter(executor.getResultByStep(), expression.getStepStrings());
tResult.setText(formatter.getFormattedString());
}else{
tResult.setText("Erro! Expressao XLPath invalida...");
}
}else{
tResult.setText("Por favor, selecione um arquivo valido.");
}
}else{
tResult.setText("Por favor, informe uma expressao XLPath.");
}
}
public static void main(String[] args) {

try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
e.printStackTrace();
}
new XLPathConsole().setVisible(true);
}
}
61
APÊNDICE C - XLPathFormatter.java
Código Java da classe XLPathFormatter, que compõe o protótipo

apresentado no capítulo 4.
package xlpath.view;
import java.util.List;
import xlpath.model.XLPathElementStore;
public class XLPathFormatter {
private String formattedString;
public XLPathFormatter(List<XLPathElementStore> resultByStep, List<String> stepStrings){

this.formattedString = format(resultByStep, stepStrings);
}
public String format(List<XLPathElementStore> resultByStep, List<String> stepStrings){

String formatted = "---------------- XLPath Result ----------------\n\n";
if(resultByStep!=null){
for(int i=0; i<resultByStep.size();i++){
formatted += "Step ("+(i+1)+"): "+stepStrings.get(i)+"\n\nLocators =
{";
if(resultByStep.get(i).getLocators()!=null){
for(int j=0; j<resultByStep.get(i).getLocators().size(); j++){
formatted +=
resultByStep.get(i).getLocators().get(j).getNodeName();
if(j<resultByStep.get(i).getLocators().size()-1){
formatted += ", ";
}
}
}
formatted += "}\nArcs = {";
if(resultByStep.get(i).getArcs()!=null){
for(int j=0; j<resultByStep.get(i).getArcs().size(); j++){
formatted +=
resultByStep.get(i).getArcs().get(j).getNodeName();
if(j<resultByStep.get(i).getArcs().size()-1){
formatted += ", ";
}
}
}
formatted += "}\nResources = {";
if(resultByStep.get(i).getResources()!=null){
for(int j=0; j<resultByStep.get(i).getResources().size(); j++){
formatted +=
resultByStep.get(i).getResources().get(j).getNodeName();
62
if(j<resultByStep.get(i).getResources().size()-1){
formatted += ", ";
}
}
}
formatted += "}\nRemotes = {";
if(resultByStep.get(i).getRemotes()!=null){
for(int j=0; j<resultByStep.get(i).getRemotes().size(); j++){
formatted +=
resultByStep.get(i).getRemotes().get(j).getNodeName();
if(j<resultByStep.get(i).getRemotes().size()-1){
formatted += ", ";
}
}
}
formatted += "}\n\n";
}
}else{
formatted = "Erro! Consulta nao pode ser processada...";
}
return formatted;
}
public String getFormattedString() {

return formattedString;
}
public void setFormattedString(String formattedString) {

this.formattedString = formattedString;
}
}
63
APÊNDICE D - XLPathExpression.java
Código Java da classe XLPathExpression, que compõe o protótipo

package xlpath.model;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class XLPathExpression {
private String expression;
private List<String> stepStrings = new ArrayList<String>();
private List<XLPathStep> steps = new ArrayList<XLPathStep>();
//Método Construtor
public XLPathExpression(String expression){
this.expression = expression;
}
//Getters and Setters

public String getExpression() {
return expression;
}
public void setExpression(String expression) {

}
public List<XLPathStep> getSteps() {

return steps;
}
public void setSteps(List<XLPathStep> steps) {

this.steps = steps;
}
public List<String> getStepStrings() {

return stepStrings;
}
public void setStepStrings(List<String> stepStrings) {

this.stepStrings = stepStrings;
}
64
public boolean makeSteps(){

boolean validity = true;
StringTokenizer st = new StringTokenizer(this.getExpression(), "/");
while(st.hasMoreTokens()){
XLPathStep step = new XLPathStep("/"+st.nextToken());
this.stepStrings.add(step.getStepString());
if(step.validate()){System.out.println("validou(Step)");
this.steps.add(step);
}else{System.out.println("nao validou(Step)");
validity = false;
}
}
return validity;
}
}
65
APÊNDICE E - XLPathStep.java
Código Java da classe XLPathStep, que compõe o protótipo apresentado no

capítulo 4.
public class XLPathStep {
private String stepString = null;
private String startElementId = null;
private String level = null;
private String axis = null;
private String elementSpec = null;
private String elementName = null;
private String attributeSpec = null;
private String attributeName = null;
private String attributeValue = null;
//Método Construtor
public XLPathStep(String stepString){
if(stepString.length()>=18){
this.stepString = stepString;
int indexIn = 0;
int indexFim = 0;
indexFim = stepString.indexOf("::");
if(indexFim>indexIn){
//Pega a primeira palavra da expressão
String firstWord = stepString.substring(indexIn+1, indexFim);
//Verifica se a primeira palavra refere-se ao level ou ao

startElementId
if(firstWord.equals("HL") || firstWord.equals("LL")){
this.level = firstWord;
}else if(!firstWord.equals("")){
this.startElementId = firstWord;
indexIn = indexFim + 1;
indexFim = stepString.indexOf("::", indexIn);
66
this.level = stepString.substring(indexIn + 1,
indexFim);
}
}
indexIn = indexFim +1;

indexFim = stepString.indexOf("::", indexIn);
this.axis = stepString.substring(indexIn + 1, indexFim);
indexIn = indexFim +1;

indexFim = stepString.indexOf("(", indexIn);
this.elementSpec = stepString.substring(indexIn + 1,
indexFim);
indexIn = indexFim;
indexFim = stepString.indexOf(")", indexIn);
if(stepString.substring(indexIn+1,
indexFim).length() != 0){
this.elementName =
stepString.substring(indexIn + 1, indexFim).replace("'", "");
}
indexIn = indexFim;
if(stepString.indexOf("(", indexIn) != -1){

indexFim = stepString.indexOf("(",
indexIn);
this.attributeSpec =
stepString.substring(indexIn + 2, indexFim);
indexIn = indexFim;
if(stepString.indexOf(")", indexIn) != -
1){
indexFim =
stepString.indexOf(")", indexIn);
if(stepString.substring(indexIn
+ 1, indexFim).equals("")){
this.attributeName =
"";
}else{
this.attributeName =
}
}
67
indexIn = stepString.indexOf("=");
indexFim = stepString.indexOf("]",
indexIn);
if(indexIn != -1){
this.attributeValue =
}else{
this.attributeValue = "";
}
}
}
}
}
}
}
}
//Getters and Setters

public String getStartElementId() {
return startElementId;
}
public String getStepString() {

return stepString;
}
public void setStepString(String stepString) {

this.stepString = stepString;
}
public void setStartElementId(String startElementId) {

this.startElementId = startElementId;
}
public String getLevel() {

return level;
}
public void setLevel(String level) {

this.level = level;
}
public String getAxis() {

return axis;
}
public void setAxis(String axis) {

this.axis = axis;
}
68
public String getElementSpec() {

return elementSpec;
}
public void setElementSpec(String elementSpec) {

this.elementSpec = elementSpec;
}
public String getElementName() {

return elementName;
}
public void setElementName(String elementName) {

this.elementName = elementName;
}
public String getAttributeSpec() {

return attributeSpec;
}
public void setAttributeSpec(String attributeSpec) {

this.attributeSpec = attributeSpec;
}
public String getAttributeName() {

return attributeName;
}
public void setAttributeName(String attributeName) {

this.attributeName = attributeName;
}
public String getAttributeValue() {

return attributeValue;
}
public void setAttributeValue(String attributeValue) {

this.attributeValue = attributeValue;
}
public boolean validate(){

if(this.level==null)this.level = "";
if(this.axis==null) this.axis = "";
if(this.elementSpec==null) this.elementSpec = "";
if(this.elementName==null) this.elementName = "";
if(this.attributeSpec==null) this.attributeSpec = "";
if(this.attributeName==null) this.attributeName = "";
if(this.attributeValue==null) this.attributeValue = "";
boolean validity = true;
if(!(this.level.equals("LL")
69
||this.level.equals("HL"))){
validity = false;
}
if(!(this.axis.equals("linked")
||this.axis.equals("arc-source")
||this.axis.equals("arc-destination"))){
validity = false;
}
if(!(this.elementSpec.equals("arc")
||this.elementSpec.equals("locator")
||this.elementSpec.equals("remote")
||this.elementSpec.equals("resource")
||this.elementSpec.equals("element"))){
validity = false;
}
if(!(this.attributeSpec.equals("attribute")||this.attributeSpec.equals(""))){
validity = false;
}
return validity;
}
}
70
APÊNDICE F - XLPathElementStore.java
Código Java da classe XLPathElementStore, que compõe o protótipo

import org.w3c.dom.Element;
public class XLPathElementStore {
private List<Element> elements = new ArrayList<Element>();

private List<Element> arcs = new ArrayList<Element>();
private List<Element> locators = new ArrayList<Element>();
private List<Element> resources = new ArrayList<Element>();
private List<Element> remotes = new ArrayList<Element>();
private List<String> registers = new ArrayList<String>();
public XLPathElementStore(){
}
public void storeElement(Element element){
if((element.getNodeType()==1)&&(!isRegistered(element))){
if(element.hasAttribute("xlink:type")){
if(element.getAttribute("xlink:type").equals("arc")){
this.elements.add(element);
this.arcs.add(element);
register(element);
}else if(element.getAttribute("xlink:type").equals("locator")){
this.locators.add(element);
register(element);
}else if(element.getAttribute("xlink:type").equals("resource")){
this.resources.add(element);
register(element);
}
}else if(element.hasAttribute("id")){
this.remotes.add(element);
register(element);
}
}
}
71
public void register(Element element){

if(!isRegistered(element)){
this.registers.add(this.generateString(element));
}
}
public boolean isRegistered(Element element){
String elementString = generateString(element);
if(!elementString.equals("")){
for(String register : this.registers){
if(register.equals(elementString)){
return true;
}
}
}
return false;
}
public String generateString(Element element){
String elementString = "";
if(element.hasAttribute("xlink:type")){
String type = element.getAttribute("type");
if(type.equals("arc")){
if((element.getParentNode()!=null)&&(element.hasAttribute("xlink:from"))
&&(element.hasAttribute("xlink:to"))){
elementString += element.getParentNode().getNodeName();
elementString += element.getNodeName();
elementString += type;
elementString += element.getAttribute("xlink:from");
elementString += element.getAttribute("xlink:to");
}
}else if(type.equals("locator")){
if((element.getParentNode()!=null)&&(element.hasAttribute("xlink:label"))){
elementString +=
element.getParentNode().getNodeName();
elementString += element.getAttribute("xlink:label");
}
}else if(type.equals("resource")){
if((element.getParentNode()!=null)&&(element.hasAttribute("xlink:label"))){
elementString += element.getParentNode().getNodeName();
elementString += element.getAttribute("xlink:label");
}
}
}else if((element.hasAttribute("id"))){
elementString += "remote";
72
elementString += element.getAttribute("id");
}
return elementString;
}
public List<Element> getElements() {

return elements;
}
public void setElements(List<Element> elements) {

this.elements = elements;
}
public List<Element> getArcs() {

return arcs;
}
public void setArcs(List<Element> arcs) {

this.arcs = arcs;
}
public List<Element> getLocators() {

return locators;
}
public void setLocators(List<Element> locators) {

this.locators = locators;
}
public List<Element> getResources() {

return resources;
}
public void setResources(List<Element> resources) {

this.resources = resources;
}
public List<Element> getRemotes() {

return remotes;
}
public void setRemotes(List<Element> remotes) {

this.remotes = remotes;
}
public List<String> getRegisters() {
return registers;
}
public void setRegisters(List<String> registers) {
this.registers = registers;
}
}
73
APÊNDICE G - XLPathExecutor.java
Código Java da classe XLPathExecutor, que compõe o protótipo apresentado

no capítulo 4.
package xlpath.controller;
import java.io.IOException;
import javax.swing.JOptionPane;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class XLPathExecutor {
private XLPathExpression expression;

private Document docXml = null;
private List<XLPathElementStore> resultByStep = new ArrayList<XLPathElementStore>();
public XLPathExecutor(XLPathExpression expression, String xmlPathAndFile){

try {
this.docXml = getDocXml(xmlPathAndFile);
} catch (Exception ex) {
ex.printStackTrace();
this.docXml = null;
JOptionPane.showMessageDialog(null, ex.getMessage(), "Erro!
"+xmlPathAndFile+" nao encontrado", JOptionPane.ERROR_MESSAGE);
}
if(this.docXml != null){
Element startElement =
getStartElement(this.expression.getSteps().get(0).getStartElementId(), this.docXml);
if(startElement!=null){
XLPathElementStore elementStore = new XLPathElementStore();
elementStore.storeElement(startElement);
XLPathProcessor xlp = new XLPathProcessor(elementStore,
this.expression);
this.resultByStep = xlp.process();
74
}
}
}
public static Document getDocXml(String xmlPathAndFile) throws

ParserConfigurationException, SAXException, IOException{
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document docXml = db.parse(xmlPathAndFile);
return docXml;
}
public Element getStartElement(String startElementId, Document docXml){
NodeList nodes = docXml.getElementsByTagName("*");

Element element;
for(int i=0; i<nodes.getLength(); i++){
if(nodes.item(i).getNodeType()==1){
element = (Element) nodes.item(i);
if((element.getAttribute("id")!=null)&&(element.getAttribute("id").equals(startElementId))){
return element;
}
}
}
return null;
}
public XLPathExpression getExpression() {

return expression;
}
public void setExpression(XLPathExpression expression) {

}
public Document getDocXml() {
return docXml;
}
public void setDocXml(Document docXml) {
this.docXml = docXml;
}
public List<XLPathElementStore> getResultByStep() {
return resultByStep;
}
public void setResultByStep(List<XLPathElementStore> resultByStep) {
this.resultByStep = resultByStep;
}
}
75
APÊNDICE H - XLPathProcessor.java
Código Java da classe XLPathProcessor, que compõe o protótipo

package xlpath.controller;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import xlpath.model.XLPathStep;
public class XLPathProcessor {
private XLPathElementStore elements;

private XLPathExpression expression;
public XLPathProcessor(XLPathElementStore elements, XLPathExpression expression){

this.elements = elements;
public List<XLPathElementStore> process(){

List<XLPathElementStore> resultByStep = new ArrayList<XLPathElementStore>();
for(int x=0; x<this.expression.getSteps().size(); x++){
if(this.elements!=null){
this.elements = axisSpecProcess(this.expression.getSteps().get(x));
if(this.elements!=null){
this.elements =
elementSpecProcess(this.expression.getSteps().get(x));
}
}
resultByStep.add(elements);
}
return resultByStep;
}
public XLPathElementStore axisSpecProcess(XLPathStep step){

XLPathElementStore axisElements = new XLPathElementStore();
if((elements.getRemotes()!=null)&&(!elements.getRemotes().isEmpty())){
List<Element> remoteRefs = null;
76
for(Element remote : elements.getRemotes()){

remoteRefs =
getRemoteReferences(remote,step.getLevel(),step.getAxis());
}
if((remoteRefs!=null)&&(!remoteRefs.isEmpty())){
for(Element remoteRef : remoteRefs){
axisElements.storeElement(remoteRef);
}
}
}
if((elements.getLocators()!=null)&&(!elements.getLocators().isEmpty())){
List<Element> locatorRefs = null;
for(Element locator : elements.getLocators()){
locatorRefs =
getLocatorReferences(locator,step.getLevel(),step.getAxis());
}
if((locatorRefs!=null)&&(!locatorRefs.isEmpty())){
for(Element locatorRef : locatorRefs){
axisElements.storeElement(locatorRef);
}
}
}
if((elements.getArcs()!=null)&&(!elements.getArcs().isEmpty())){
List<Element> arcRefs = null;
for(Element arc : elements.getArcs()){
arcRefs = getArcReferences(arc,step.getLevel(),step.getAxis());
}
if((arcRefs!=null)&&(!arcRefs.isEmpty())){
for(Element arcRef : arcRefs){
axisElements.storeElement(arcRef);
}
}
}
if((elements.getResources()!=null)&&(!elements.getResources().isEmpty())){
List<Element> resourceRefs = null;
for(Element resource : elements.getResources()){
resourceRefs =
getResourceReferences(resource,step.getLevel(),step.getAxis());
}
if((resourceRefs!=null)&&(!resourceRefs.isEmpty())){
for(Element resourceRef : resourceRefs){
axisElements.storeElement(resourceRef);
}
}
}
return axisElements;
}
77
public XLPathElementStore elementSpecProcess(XLPathStep step){

XLPathElementStore elementSpecElements = new XLPathElementStore();
if(step.getElementSpec().equals("arc")&&this.elements.getArcs()!=null){
for(Element arc : this.elements.getArcs()){
elementSpecElements.storeElement(arc);
}
}else
if(step.getElementSpec().equals("locator")&&this.elements.getLocators()!=null){
for(Element locator : this.elements.getLocators()){
elementSpecElements.storeElement(locator);
}
}else
if(step.getElementSpec().equals("resource")&&this.elements.getResources()!=null){
for(Element resource : this.elements.getResources()){
elementSpecElements.storeElement(resource);
}
}else
if(step.getElementSpec().equals("remote")&&this.elements.getRemotes()!=null){
for(Element remote : this.elements.getRemotes()){
elementSpecElements.storeElement(remote);
}
}else if(step.getElementSpec().equals("element")){
elementSpecElements = this.elements;
}
if(!step.getElementName().equals("")){
XLPathElementStore auxElements = new XLPathElementStore();
for(Element element : elementSpecElements.getElements()){
if(element.getNodeName().equals(step.getElementName())){
if(step.getAttributeSpec().equals("attribute")
&&
element.getAttribute("xlink:"+step.getAttributeName()).equals(step.getAttributeValue())){
auxElements.storeElement(element);
}else if(step.getAttributeSpec().equals("")){
}
}
}
elementSpecElements = auxElements;
}else {
XLPathElementStore auxElements = new XLPathElementStore();
for(Element element : elementSpecElements.getElements()){
if(step.getAttributeSpec().equals("attribute")
&&
element.getAttribute("xlink:"+step.getAttributeName()).equals(step.getAttributeValue())){
}else if(step.getAttributeSpec().equals("")){
}
}
elementSpecElements = auxElements;
78
return elementSpecElements;
}
public List<Element> getRemoteReferences(Element remote, String level, String axis){

List<Element> locators = new ArrayList<Element>();
NodeList docNodes =
remote.getOwnerDocument().getElementsByTagName("*");
for (int i = 0; i < docNodes.getLength(); i++) {
if(docNodes.item(i).getNodeType()==1){
if
((docNodes.item(i).getAttributes().getNamedItem("xlink:type")!=null)&&
(docNodes.item(i).getAttributes().getNamedItem("xlink:type").getNodeValue().equals("locat
or"))) {
Element elementLocator = (Element)
docNodes.item(i);
String locatorHref =
elementLocator.getAttribute("xlink:href");
if(locatorHref!=null){
String locatorRef =
locatorHref.substring(locatorHref
.lastIndexOf("#") + 1,
locatorHref.length());
if
(remote.getAttribute("id").equals(locatorRef)) {
locators.add(elementLocator);
}
}
}
}
}
if(level.equals("LL")&&(axis.equals("linked"))){
return locators;
}else if(level.equals("LL")&&((axis.equals("arc-source"))||(axis.equals("arc-
destination")))){
return null;
}else if(level.equals("HL")&&(locators!=null)){
List<Element> arcs = new ArrayList<Element>();
for(Element locator : locators){
if(axis.equals("linked")||axis.equals("arc-source")){
Node link = locator.getParentNode();
for (int i = 0; i < link.getChildNodes().getLength(); i++)
{
if(link.getChildNodes().item(i).getNodeType()==1){
Element linkChild = (Element)
link.getChildNodes().item(i);
if((linkChild.hasAttribute("xlink:type"))
79
&&(linkChild.getAttribute("xlink:type").equals("arc"))){
if((linkChild.hasAttribute("xlink:from"))
&&(linkChild.getAttribute("xlink:from").equals(locator.getAttribute("xlink:label")))){
arcs.add(linkChild);
}
}
}
}
}if(axis.equals("linked")||axis.equals("arc-source")){
for (int i = 0; i < link.getChildNodes().getLength(); i++)
{
Element linkChild = (Element)
link.getChildNodes().item(i);
if((linkChild.hasAttribute("xlink:to"))
&&(linkChild.getAttribute("xlink:to").equals(locator.getAttribute("xlink:label")))){
arcs.add(linkChild);
}
}
}
}
}
}
return arcs;
}else{
return null;
}
}
public List<Element> getLocatorReferences (Element locator, String level, String axis){

List<Element> references = new ArrayList<Element>();
if(axis.equals("linked")){
Document docXml = link.getOwnerDocument();
String remoteUri = locator.getAttribute("xlink:href");
if(remoteUri!=null){
80
String remoteId = remoteUri.substring(remoteUri.lastIndexOf("#") +

1, remoteUri.length());
NodeList nodes = docXml.getElementsByTagName("*");
Element element;
for(int i=0; i<nodes.getLength(); i++){
if(nodes.item(i).getNodeType()==1){
element = (Element) nodes.item(i);
if((element.hasAttribute("id"))&&(element.getAttribute("id").equals(remoteId))){
references.add(element);
i = nodes.getLength();
}
}
}
}
}
if(axis.equals("arc-source")||axis.equals("linked")){
for (int i = 0; i<link.getChildNodes().getLength(); i++) {
Element linkChild = (Element) link.getChildNodes().item(i);
if((linkChild.getAttribute("xlink:type").equals("arc"))){
&&(linkChild.getAttribute("xlink:from").equals(locator.getAttribute("xlink:label")))){
references.add(linkChild);
}
}
}
}
}
if(axis.equals("arc-destination")||axis.equals("linked")){
&&(linkChild.getAttribute("xlink:to").equals(locator.getAttribute("xlink:label")))){
}
}
}
}
}
return references;
}
public List<Element> getArcReferences (Element arc, String level, String axis){

81

List<Element> locSource = new ArrayList<Element>();
List<Element> locDest = new ArrayList<Element>();
Node link = arc.getParentNode();
if(level.equals("LL")||level.equals("HL")){
if(linkChild.hasAttribute("xlink:label")
&&linkChild.getAttribute("xlink:label").equals(arc.getAttribute("xlink:from"))){
if(linkChild.getAttribute("xlink:type").equals("locator")){
locDest.add(linkChild);
}
}
}
if(axis.equals("arc-
destination")||axis.equals("linked")){
if(linkChild.hasAttribute("xlink:label")
&&linkChild.getAttribute("xlink:label").equals(arc.getAttribute("xlink:to"))){
if(linkChild.getAttribute("xlink:type").equals("locator")){
locSource.add(linkChild);
}
}
}
}
if(level.equals("HL")){
references.clear();
Document docXml = link.getOwnerDocument();
if(locDest!=null){
for(Element locator : locDest){
String remoteUri =
locator.getAttribute("xlink:href");
String remoteId =
remoteUri.substring(remoteUri.lastIndexOf("#") + 1, remoteUri.length());
NodeList nodes =
docXml.getElementsByTagName("*");
Element element;
for(int j=0;
j<nodes.getLength(); j++){
if(nodes.item(j).getNodeType()==1){
82
element = (Element) nodes.item(j);
}
}
}
}
}
}
}
if(axis.equals("arc-
destination")||axis.equals("linked")){
if(locSource!=null){
for(Element locator : locSource){
String remoteUri =
locator.getAttribute("xlink:href");
String remoteId =
remoteUri.substring(remoteUri.lastIndexOf("#") + 1, remoteUri.length());
NodeList nodes =
docXml.getElementsByTagName("*");
Element element;
for(int j=0;
j<nodes.getLength(); j++){
if(nodes.item(j).getNodeType()==1){
element = (Element) nodes.item(j);
}
}
}
}
}
}
}
}
}
}
return references;
}
public List<Element> getResourceReferences (Element resource, String level, String axis){

83

Node link = resource.getParentNode();
&&(linkChild.getAttribute("xlink:from").equals(resource.getAttribute("xlink:label")))){
}
}
}
}
}
if(axis.equals("arc-destination")||axis.equals("linked")){
&&(linkChild.getAttribute("xlink:to").equals(resource.getAttribute("xlink:label")))){
}
}
}
}
}
return references;
}
}

Monografia Marcelo Mendonça Xlpath

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Monografia Marcelo Mendonça Xlpath

Enviado por

Direitos autorais:

Formatos disponíveis

FACULDADE DE CIÊNCIA E TECNOLOGIA – ÁREA 1

MARCELO MENDONÇA DOS SANTOS

Trabalho de Conclusão de Curso

Orientador: Prof. Paulo Caetano da Silva

Uma Linguagem Para Navegação em Links XML

Trabalho de Conclusão de Curso

Aprovada em 30 de junho de 2010.

Alexandre do Nascimento Silva – Mestre em Modelagem Computacional

Wanja Marly de Oliveira Mascarenhas – Mestre em Modelagem Computacional

Paulo Caetano da Silva – Mestre em Redes de Computadores

Agradeço a meus pais, Gilberto e Mariluce, pelas portas abertas.

A rápida expansão de XML enquanto padrão de representação e intercâmbio

Palavras-chave: XLPath, XLink, XML, Linguagem de Consulta.

The quick expansion of XML as standard of representation and exchanging of

Keywords: XLPath, XLink, XML, Query Language.

Figura 1. Encadeamento de Documentos XML ......................................................... 19

Figura 2. Árvore de Elementos XML ......................................................................... 21

Figura 3. Mecanismos de XPath ............................................................................... 23

Figura 4. Abordagens XSPath em Alto e Baixo Nível................................................ 25

Figura 5. Link Estendido em Abordagem de Baixo Nível .......................................... 36

Figura 6. Link Estendido em Abordagem de Alto Nível ............................................. 37

Figura 7. Arquitetura de um Processador XLPath ..................................................... 46

Figura 8. Console do Processador XLPath ............................................................... 47

Figura 9. Resultados no Console XLPath ................................................................. 48

Quadro 1. Exemplo de Link Estendido ...................................................................... 17

Quadro 2. Exemplos de Elementos XML .................................................................. 20

Quadro 3. Resultado de Uma Consulta XPath+......................................................... 28

Quadro 4. Algoritmo NavigationPath ......................................................................... 33

Quadro 5. Link Estendido Grade Curricular............................................................... 35

Quadro 6. Equivalente Estendido de um Link Simples.............................................. 38

Quadro 7. Notação EBNF para XLPath ..................................................................... 44

Quadro 8. Saída do Processador XLPath ................................................................. 49

Tabela 1. Tipos de Elementos e Atributos Globais em XLink.................................... 18

Tabela 2. Eixos de XPath .......................................................................................... 22

Tabela 3. Especificação de Nó em XPath ................................................................. 22

Tabela 4. Exemplos de Expressões XSPath ............................................................. 26

Tabela 5. Simbologia para Representação de Links ................................................. 34

Tabela 6. Especificação de Eixo em XLPath ............................................................. 41

Tabela 7. Especificação de Elemento em XLPath..................................................... 43

Tabela 8. Predicados em XLPath .............................................................................. 44

1.1. MOTIVAÇÃO ................................................................................................ 12

1.2. OBJETIVOS ................................................................................................. 13

1.3. ESTRUTURA DO DOCUMENTO ................................................................ 14

2.1. XLINK ........................................................................................................... 15

2.2. XPATH ......................................................................................................... 19

2.3. XSPATH ....................................................................................................... 24

2.4. XPATH+ ........................................................................................................ 26

2.5 CONCLUSÃO .............................................................................................. 29

3. XLPATH: UMA LINGUAGEM PARA NAVEGAÇÃO EM LINKS XML .............. 30

3.1. REQUISITOS PARA XLPATH ..................................................................... 30

3.2. UM MODELO DE DADOS PARA XML COM XLINK .................................... 31

3.3. REPRESENTAÇÃO DE LINKS .................................................................... 33

3.3.1. Representação em baixo nível ........................................................... 34

3.3.2. Representação em alto nível .............................................................. 36

3.4. ABORDAGEM PARA LINKS SIMPLES ....................................................... 37

3.5. ABORDAGEM PARA LINKS COM ARCOS IMPLÍCITOS............................ 38

3.6. SINTAXE E SEMÂNTICA............................................................................. 39

3.6.1. Especificação de eixo ......................................................................... 40

3.6.2. Especificação de elemento ................................................................. 41

3.7. ARQUITETURA DE UM PROCESSADOR XLPATH ................................... 45

3.8. CONCLUSÃO .............................................................................................. 46

4. ESTUDO DE CASO ........................................................................................... 47

4.1. PROTÓTIPO DE UM PROCESSADOR XLPATH ........................................ 47