XSLT e recursividade estrutural

Apresentação em tema: "XSLT e recursividade estrutural"— Transcrição da apresentação:

1 XSLT e recursividade estrutural
Helena Galhardas DEI IST

2 Agenda Recursividade estrutural XSLT

3 Recursividade estrutural: um paradigma diferente
Dados são vistos como conjuntos e um operador de união: {a:3, a:{b:”one”, c:5}, b:4} = {a:3} U {a:{b:”one”,c:5}} U {b:4}

4 Exemplo 1 Encontrar todos os inteiros nos dados
f($T1 U $T2) = f($T1) U f($T2) f({$L: $T}) = f($T) f({}) = {} f($V) = if isInt($V) then {result: $V} else {} Dadas duas árvores $T1 E $T2 $V é um valor atómico Função recursiva f1 que usa pattern matching. Como funciona: Última linha define f1 sobre valores atómicos, as outras 3 sobre valores complexos A função chama-se a si própria recursivamente até que encontra uma folha; aí retorna {} ou {result: $V} {} significa um grafo com um só nó (que não é um valor) e não tem arestas de saída. a b c 3 “one” 5 4 result 3 5 4

5 Exemplo 2 O que faz? f($T1 U $T2) = f($T1) U f($T2)
f({$L: $T}) = if $L=a then {b:f($T)} else {$L:f($T)} f({}) = {} f($V) = $V

6 Exemplo 3 Aumentar os preços dos motores de 10%
f($T1 U $T2) = f($T1) U f($T2) f({$L: $T}) = if $L= engine then {$L: g($T)} else {$L: f($T)} f({}) = {} f($V) = $V g($T1 U $T2) = g($T1) U g($T2) g({$L: $T}) = if $L= price then {$L:1.1*$T} else {$L: g($T)} g({}) = {} g($V) = $V engine body part price 100 1000 engine body part price 110 1100 100 1000

7 Exemplo 4 Encontrar todas as sub-árvores que se conseguem chegar por (a.b)*.a a b a f($T1 U $T2) = f($T1) U f($T2) f({$L: $T}) = if $L= a then g($T} U $T else { } f({}) = { } f($V) = { } g($T1 U $T2) = g($T1) U g($T2) g({$L: $T}) = if $L= b then f($T) g({}) = { } g($V) = { }

8 Forma genérica de recursividade estrutural
f1($T1 U $T2) = f1($T1) U f1($T2) f1({$L: $T}) = E1($L, f1($T),...,fk($T), $T) f1({}) = { } f1($V) = { } fk($T1 U $T2) = fk($T1) U fk($T2) fk({$L: $T}) = Ek($L, f1($T),...,fk($T), $T) fk({}) = { } fk($V) = { } Cada E1, ..., Ek consiste só {_ : _}, U, if_then_else_

9 Execução da recursividade estrutural
Calcula as funções recursivas começando com f1 na raíz Terminação é garantida Quão eficientemente se pode executar? Não vamos detalhar

10 XSL XSL composto por: Linguagem para transformar documentos XML (XSLT) Vocabulário XML para especificar semântica de formatação: XSL-FO (formatting objects) XSLT transforma um doc XML numa árvore de resultado: Outro doc XML Um doc HTML Um doc que contenha FO XSL-FO em geral: Corresponde a uma ou mais áreas no écran ou página Tem props para descrever o aspecto visual da área Tem como conteúdo ou texto Objecto externo (image, applet, etc.), ou Mais objectos de formatação Utiliza XPath

11 Programa XSLT XSL program = template-rule ... template-rule
template-rule = match pattern + template Examplo: Encontra os títulos de todos os livros <xsl:template match = “* | /”> <xsl:apply-templates/> </xsl:template> <xsl:template match = “/bib/*/title”> <result> <xsl:value-of select = “.” /> </result> Um doc XML é visto como uma árvore, a árvore de origem Pattern para fazer match de nós na árvore origem Template de instruções e elementos resultado literais Para construir a árvore de resultado, a árvore origem é atravessada fazendo corresponder os padrões das regras aos nós na árvore Se o padrão corresponde, então o template é executado para o nó correspondente e um fragmento da árvore resultado é criado Usa a sintaxe XML

12 Regras XSLT (1) Regras são indicadas pelos elementos xsl:template
O padrão é especificado usando uma expressão XPath no valor do atributo match template é o conteúdo do elemento xsl:template Ex: <xsl:template match = “book”> <xsl:apply-templates/> </xsl:template> template corresponde aos elementos book <xsl:apply-templates/> é uma instrução que aplica os templates a todos os filhos do elemento que fez match no template

13 Regras XSLT (2) <xsl:template match = “/bib/*/title”> <result> <xsl:value-of select = “.” /> </result> </xsl:template> <result> e </result> são elementos resultado literais xsl:value-of é uma instrução que produz como saída o que é seleccionado pelo .valor do atributo select O valor do atributo select é uma expressão XPath

14 Modelo de processamento XSLT
Processador lê um doc XML e uma stylesheet XSLT O processamento começa no nó raíz do documento Cada nó é processado do seguinte modo: Procurar a regra template com o melhor matching pattern Se encontrado, executar o conteúdo do template (a maior parte das vezes seleccionando mais nós para processar) Se não fôr encontrado, prosseguir com a lista de nós filhos Uma lista de nós é processada percorrendo os nós por ordem O processo continua recursivamente até não existirem mais novos para serem seleccionados

15 Controlo de fluxo <xsl:template match = “* | /”> <xsl:apply-templates/> </xsl:template> <xsl:template match=“a”> <A><xsl:apply-templates/></A> <xsl:template match=“b”> <B><xsl:apply-templates/></B> <xsl:template match=“c”> <C><xsl:value-of/></C>

16 <a> <e> <b> <c> 1 </c>
<a> <c> 3 </c> </a> </e> <c> 4 </c> <A> <B> <C> 1 </C> <C> 2 </C> </B> <A> <C> 3 </C> </A> <C> 4 </C>

17 XSLT e recursividade estrutural
Equivalente a: f(T1 U T2) = f(T1) U f(T2) f({L: T}) = if L= c then {C: t} else L= b then {B: f(t)} else L= a then {A: f(t)} else f(t) f({}) = {} f(V) = V  <xsl:template match=“c”>  <xsl:template match=“b”>  <xsl:template match=“a”>  <xsl:template match = “* | /”>

18 XSLT vs recursividade estrutural
Sobre árvores Pode entrar em ciclo infinito Recursividade estrutural: Grafos arbitrários Termina sempre

19 Programa XSLT simples Copia a entrada:
<xsl:template match = “/”> <xsl:apply-templates/> </xsl:template> <xsl:template match = “text()”> <xsl:value-of select=“.”/> </xsl:template> <xsl:template match = “*”> <xsl:element name=“name(.)”> <xsl:apply-templates/> </xsl:element>

20 Resolução de conflitos para regras de template
Se várias regras de template fazem match, escolher a que tem maior prioridade Prioridades podem ser: Explicitas: <xsl:template match=“abc” priority=“1.41”> implicitas: regras ad-hoc dadas pelo W3, baseadas no match match=“abc”  prioridade 0. match=“[... some namespace name... ]”  prioridade match=“node()”  prioridade -0.5.

21 Modos em XSLT Modo = nome para um grupo de template rules
Útil quando o mesmo nó tem que ser percorrido várias vezes Equivalente a ter múltiplas funções recursivas

22 Exemplo Calcular o caminho (a.b)* : f(T1 U T2) = f(T1) U f(T2)
f({a: T}) = {result:T} U g(T) f({}) = {} f(V) = V g(T1 U T2) = g(T1) U g(T2) g({b: T}) = f(T) g({}) = {} g(V) = V <xsl:template match = “/”> <xsl:apply-templates mode=“f”/> </xsl:template> <xsl:template match=“*” mode=“f”/> <xsl:template match=“a” mode=“f”> <result> <xsl:copy-of match=“.”/> </result> <xsl:apply-templates mode=“g”/> <xsl:template match=“*” mode=“g”> <xsl:template match=“b” mode=“g”> <xsl:apply-templates mode=“f”/>

23 Exercício Escreva um programa XSLT que transforme o doc XML:
<teaches> <teaches-tuple course="XML" lecturer="Peter Wood"/> <teaches-tuple course="Algorithms" lecturer="Trevor Fenner"/> </teaches> Noutro com o formato: <teaches-tuple> <course>XML</course> <lecturer>Peter Wood</lecturer> </teaches-tuple> <course>Algorithms</course> <lecturer>Trevor Fenner</lecturer> Assuma que teaches é o elemento raíz e que os atributos course e lecturer são obrigatórios. O programa deve executar-se para qualquer número de ocorrências do elemento teaches-tuple.

24 Tópicos próximas aulas
(Prof. Pável Calado) Extracção de dados da Web Extracção de informação

25 Referências S. Abiteboul, P. Buneman, D. Suciu, “Data on the Web, From Relations to Semistructured Data and XML”, Morgan Kaufmann, 2000, (caps 5 e 6) Peter Wood, Slides on “Representing and Querying Data on the Web”, Dan Suciu, Slides on “The semistructured data model”, CSE 590ds: Management of XML and Semistructured Data, W3C's XSL home page hands-on-xsl.pdf hands-on XSL: a simple exercise demonstrating the principles of XSLT (previously available from IBM developerWorks) nwalsh.com/docs/tutorials/xsl/ an XSL tutorial by Paul Grosso and Norman Walsh an XSLT reference using examples; links to other XML tutorials metalab.unc.edu/xml/books/bible/updates/14.html a chapter from the XML Bible on XSL Transformations (and XPath)