Preparação para o Exame 730 DB2 9 Fundamentals, Parte 7: Apresentando XQuery

O DB2® 9 apresenta suporte para XQuery, uma linguagem padrão de mercado projetada expressamente para consultar dados XML. Com XQuery e DB2 9, é possível recuperar documentos XML inteiros ou fragmentos de XML armazenados em colunas XML. Também é possível especificar filtros baseados em XML, transformar saída XML e incorporar lógica condicional a consultas. Este tutorial apresenta o suporte do DB2 a XQuery, explica diversos conceitos básicos da linguagem e mostra como é possível escrever e executar XQueries simples com relação a dados XML armazenados no DB2. Este é o sétimo de uma série de sete tutoriais para ajudá-lo a se preparar para o exame 730 DB2 9 Fundamentals.

C. M. Saracco, Senior Software Engineer, IBM China

C. M. Saracco é engenheira de software senior no Laboratório da IBM no Vale do Silício. Ela escreveu dois livros sobre tópicos de gerenciamento de banco de dados (um em coautoria com Charles J. Bontempo) e deu seminários na América do Norte, na América do Sul e na Europa.



16/Set/2011

Antes de Iniciar

Para ajudá-lo a preparar para os exames de certificação do DB2, este tutorial apresenta XQuery e seu suporte no DB2. Você já deve estar familiarizado com o DB2 V9 e seu suporte a pureXML antes de fazer este tutorial.

Este tutorial foca o uso de XQuery para consultar dados XML do DB2. Ele fornece uma discussão muito limitada sobre como usar SQL/XML (SQL com extensões XML) para consultar dados XML do DB2. Para obter informações adicionais sobre o suporte do DB2 para funções SQL/XML padrão de mercado, consulte Recursos.

Sobre esta série

Pensando em buscar certificação nos fundamentos do DB2 (Exame 730)? Nesse caso, veio ao local certo. Esta série de sete tutoriais de preparação para certificação de DB2 abrange todo o básico -- os tópicos que você precisará entender antes de ler a primeira questão do exame. Mesmo se não estiver planejando em buscar certificação imediatamente, este conjunto de tutoriais é um ótimo local para começar a aprender o que há de novo no DB2 9.

Sobre este tutorial

Este tutorial explora recursos básicos do novo suporte a XQuery do DB2. Revisa diferenças chaves entre XQuery e SQL, explora expressões XPath e "FLWOR" e ensina como escrever XQueries simples sobre dados XML do DB2.

Este tutorial é para usuários do DB2 que planejam trabalhar com documentos XML armazenados em suas estruturas hierárquicas nativas dentro de colunas XML de tabelas do DB2. O material deste tutorial cobre tópicos de XML que são abordados nas Seções 1, 4 e 5 do teste. É possível visualizar esses objetivos em: http://www-03.ibm.com/certify/tests/obj730.shtml. Você deve estar familiarizado com tecnologias básicas de XML e com o novo suporte a pureXML do DB2 antes de fazer este tutorial. Se necessário, consulte Recursos para obter material de base.

Objetivos

Após concluir este tutorial, você deve poder:

  • Entender os conceitos fundamentais de XQuery
  • Escrever XQueries simples usando diversas expressões comuns

Pré-requisitos

Este tutorial é para pessoas familiares com a tecnologia XML básica e o novo suporte do DB2 para armazenamento e gerenciamento de dados pureXML. Você deve entender a natureza hierárquica de documentos XML, o conceito de boa formação e como elementos e atributos podem ser usados. Você também deve entender como é possível armazenar documentos XML bem formados em sua estrutura hierárquica nativa usando o DB2 9.

Requisitos do sistema

Não é necessário ter uma cópia do DB2 para concluir este tutorial, mas para executar os exemplos é necessário ter um sistema no qual o DB2 9 está instalado. Qualquer plataforma suportada será suficiente, mas alguns dos exemplos são padronizados para as plataformas Windows. Você aproveitará melhor o tutorial se fizer download da versão de avaliação gratuita do IBM DB2 9 para trabalhar com este tutorial.


Visão Geral do XQuery

O DB2 9 apresenta suporte para XQuery, uma nova linguagem de consulta projetada especificamente para trabalhar com dados XML. Parte do padrão de mercado W3C, XQuery permite que usuários naveguem pela estrutura hierárquica inerente em documentos XML. Como resultado, é possível recuperar documentos XML ou fragmentos de documentos usando XQuery. Também é possível escrever XQueries que incluam predicados baseados em XML para "remover por filtro" dados indesejados dos resultados que o DB2 irá retornar. XQuery oferece muitos outros recursos, como a capacidade de transformar saída XML e incorporar lógica condicional às suas consultas.

Antes de aprender como usar XQuery, é necessário entender alguns conceitos fundamentais sobre a linguagem.

Fundamentos de XQuery

Uma XQuery sempre transforma um valor do XQuery Data Model em outro valor do XQuery Data Model. Um valor no XQuery Data Model é uma sequência de zero ou mais itens. Um item pode ser:

  • Qualquer valor atômico
  • Um nó XML, como um elemento, atributo ou nó de texto (às vezes chamado de um fragmento de documento XML)
  • Um documento XML integral

Frequentemente, a entrada em uma XQuery é uma coleção de documentos XML.

A Listagem 1 mostra um documento XML que contêm oito nós de elementos, um nó de atributo e seus nós de texto. Os nós de elementos são representados por identificações de elementos. Client, Address, street, city, state, zip e ambos os elementos email são todos nós de elementos neste documento. Se der uma olhada de perto no elemento Client, verá que contém um nó de atributo para o id do cliente. Alguns dos nós de elementos do documento têm nós de texto associados a eles. Por exemplo, o nó de texto para o elemento city é San Jose.

Listagem 1. Documento XML de amostra
<Client id="123"> 
	<Address>
		<street>9999 Elm St.</street>
		<city>San Jose</city>
		<state>CA</state>
		<zip>95141</zip>
	</Address>
	<email>anyemail@yahoo.com</email>
	<email>anotheremail@yahoo.com</email>
</Client>

A Figura 1 mostra os nós dentro desse documento de amostra.

Figura 1. Nós de elementos, atributos e texto em um documento XML de amostra
Nós de elementos, atributos e texto em um documento XML de amostra

A linguagem XQuery baseia-se em outros padrões XML, como XPath, que define como usuários podem navegar por um documento XML, e XML Schema, que permite que usuários especifiquem a estrutura e os tipos de dados válidos para seus documentos. Você aprenderá como incorporar expressões XPath em XQueries neste tutorial.

XQuery fornece diversos diferentes de tipos de expressões que podem ser combinados de qualquer maneira que você desejar. Cada expressão retorna uma sequência de valores que pode ser usada como entrada para outras expressões. O resultado da expressão mais externa é o resultado da consulta.

Este tutorial discute dois tipos importantes de expressões XQuery:

Expressão de caminho
Permite que usuários naveguem, ou "percorram", a hierarquia de um documento XML e retorna nós localizados no final do caminho.
Expressão FLWOR
É muito semelhante a uma expressão SELECT-FROM-WHERE em SQL. É usada para iterar por meio de uma sequência de itens e retornar, como opção, algo que é computado a partir de cada item.

Como XQuery difere de SQL

Muitos usuários de SQL supõem, erroneamente, que XQuery é muito semelhante a SQL. No entanto, XQuery difere muito de SQL em muitas maneiras, pois as linguagens foram projetadas para funcionarem com diferentes modelos de dados que têm diferentes características. Documentos XML contêm hierarquias e possuem uma ordem inerente. Em contraste, as tabelas suportadas por DBMSs relacionais (ou, mais precisamente, DBMSs baseados em SQL) são simples e baseadas em conjuntos, de forma que linhas não são ordenadas.

Essas são apenas algumas das diferenças entre XQuery e SQL. Está além do escopo deste tutorial de introdução fornecer uma lista exaustiva, mas Recursos tem mais sobre esse tópico.

Essas diferenças em modelos de dados resultam em diferenças significativas nas linguagens de consulta projetadas para suportarem os mesmos. Por exemplo, XQuery permite que programadores naveguem pela estrutura hierárquica de XML. SQL simples (sem extensões XML) não tem -- nem precisa de -- expressões equivalentes para "navegar" pelas estruturas de dados tabulares. XQuery suporta dados tipificados e não tipificados, enquanto que dados SQL sempre são definidos com um tipo específico. XQuery não possui valores nulos, pois documentos XML omitem dados ausentes ou desconhecidos. SQL usa nulos para representar valores de dados ausentes ou desconhecidos. XQuery retorna sequências de dados XML; SQL retorna conjuntos de resultados de vários tipos de dados SQL. Por fim, XQuery opera somente em dados XML. SQL opera em colunas definidas em tipos SQL tradicionais e SQL/XML (SQL com extensões XML) opera em dados XML e em tipos tradicionais de dados SQL.

Expressões de caminho em XQuery

XQuery suporta expressões XPath que permitem que usuários naveguem por uma hierarquia de documentos XML para localizar partes de interesse. Está além do escopo deste tutorial discutir XPath em detalhes, mas vamos revisar alguns exemplos simples aqui.

Expressões XPath parecem muito com as expressões usadas quando se trabalha com um sistema de arquivos de computador tradicional. Considere como você navega por diretórios Unix ou Windows e terá uma ideia de como é possível navegar por um documento XML usando XPath.

Uma expressão de caminho em XQuery consiste em uma série de "etapas" separadas por caracteres barra. Em sua forma mais simples, cada etapa navega para baixo em uma hierarquia XML para localizar os filhos dos elementos retornados pela etapa anterior. Cada etapa em uma expressão de caminho também pode conter um predicado que filtra os elementos retornados por essa etapa, retendo somente elementos que satisfazem alguma condição. Você verá um exemplo disso em um momento.

Uma tarefa comum envolve a navegação da raiz do documento XML (no nível superior na hierarquia XML) até um nó específico de interesse. Por exemplo, para recuperar os elementos email no documento mostrado na Listagem 2 abaixo, você poderia escrever:

Listagem 2. Navegando até os elementos email
/Client/email

Se o documento contiver diversos elementos email e você quiser recuperar somente o primeiro, poderia escrever:

Listagem 3. Navegando até o primeiro elemento email
/Client/email[1]

Além de especificar nós de elementos em suas expressões de caminho, é possível especificar nós de atributos usando o símbolo @ para distinguir um atributo de um elemento. Esta expressão de caminho navega até o primeiro elemento email do elemento Client que contém um atributo id igual a 123:

Listagem 4. Especificando um nó e valor de atributo
/Client[@id='123']/email[1]

O exemplo anterior incorporou um predicado de filtragem com base em um valor de atributo. Também é possível filtrar por outros valores de nós. Com bastante frequência, usuários de XPath filtram por valores de elementos, conforme mostrado nesta expressão que retorna o elemento zip de todos os clientes que vivem na Califórnia:

Listagem 5. Filtrando por um valor de elemento
/Client/Address[state="CA"]/zip

É possível usar um curinga ("*") para corresponder qualquer nó na respectiva etapa de sua expressão de caminho. O exemplo a seguir recupera qualquer elemento city localizado abaixo de qualquer filho imediato do elemento Client.

Listagem 6. Usando um curinga
/Client/*/city

Considerando nosso documento de amostra, isso retornará um elemento city com um valor igual a San Jose. Uma maneira mais precisa de navegar até esse elemento city único seria:

Listagem 7. Uma maneira mais precisa de navegar até o elemento city
/Client/Address/city

A Listagem 8 mostra alguns exemplos de outros tipos de expressões de caminho.

Listagem 8. Mais expressões de caminho e seus significados
//*                        (Retrieves all nodes in the document) 

//email                    (Finds email elements anywhere in the document) 

/Client/email[1]/text()    (Retrieves the text node of the first email element 
                                     beneath the Client element)

/Client/Address/*          (Selects all child nodes of the Address sub-element of 
                                      root Client element)

/Client/data(@id)          (Returns the value of the id attribute of the Client 
                                      element)

/Client/Address[state="CA"]/../email    (Finds the email elements of clients with an 
                                       address in California. 
                             The ".." step navigates back to the parent of the Address
                              node.)

Observe que XPath faz distinção entre maiúsculas e minúsculas. Isso é importante lembrar ao escrever XQueries, já que isso representa outra maneira em que XQuery difere de SQL. Por exemplo, se tiver incorporado a expressão de caminho "/client/address" em sua XQuery, você não receberia quaisquer resultados para o documento de amostra mostrado na Listagem 1.

Expressões FLWOR em XQuery

As pessoas frequentemente referem-se a expressões FLWOR em XQuery. Como um bloco SELECT-FROM-WHERE em SQL, uma expressão FLWOR de XQuery pode conter diversas cláusulas denotadas por palavras-chave. As cláusulas de uma expressão FLWOR começam com as seguintes palavras-chave:

  • for: Itera por uma sequência de entrada, ligando uma variável a cada item de entrada
  • let: Declara uma variável e designa a ela um valor, que pode ser uma lista contendo diversos itens
  • where: Especifica critérios para filtragem de resultados da consulta
  • order by: Especifica a ordem de classificação do resultado
  • return: Define o resultado a ser retornado

Vamos revisar cada palavra-chave resumidamente. Vamos discutir for e return em uma seção para que você possa ver um exemplo completo. (Sem a cláusula return , a expressão estaria incompleta.)

for e return
As palavras-chave for e return são usadas para iterar sobre uma sequência de valores e retornar algo para cada valor. Segue um exemplo muito simples:
for $i in (1, 2, 3)
return $i

Em XQuery, nomes de variáveis têm como prefixo um símbolo de dólar ("$"). Portanto, o exemplo anterior liga os valores numéricos 1, 2 e 3 à variável $i, um por vez, e para cada ligação retorna o valor de $i. A saída da expressão anterior é uma sequência de três valores:

1
2
3
let
As pessoas às vezes têm dificuldades para distinguir quando usar a palavra-chave let em vez de for. A palavra-chave let não itera por uma sequência de entrada, ligando cada item a uma variável (como a palavra-chave for faz). Em vez disso, let designa um valor de entrada único para uma variável, mas esse valor de entrada pode ser uma sequência de zero, um ou mais itens. Como resultado, for e let se comportam de forma bastante diferente em XQueries.

Um exemplo deve ajudar a esclarecer a distinção. Considere a expressão a seguir que usa a palavra-chave for e preste muita atenção à saída retornada:

for $i in (1, 2, 3) 
return <output> {$i} </output>


<output>1</output>
<output>2</output>
<output>3</output>

A linha final da expressão faz com que um novo elemento denominado output seja retornado para cada iteração. O valor para esse elemento é o valor de $i. Como $i é configurado para os valores numéricos 1, 2 e 3, a expressão XQuery retorna três elementos de saída, cada um com um valor diferente.

Agora, considere uma expressão semelhante que use a palavra-chave let :

let $i := (1, 2, 3) 
return <output>{$i}</output>


<output>1 2 3</output>

A saída é bastante diferente. Consiste em um único elemento de saída com os valor igual a "1 2 3".

Estes dois exemplos ilustram um ponto importante a se lembrar: a palavra-chave for itera por itens em uma sequência de entrada uma por vez, ligando cada à variável especificada. Por contraste, a palavra-chave let liga todos os itens na sequência de entrada de uma vez à variável especificada.

where
Na XQuery, where funciona muito como a cláusula WHERE em SQL: permite aplicar critérios de filtragem à sua consulta. Considere o exemplo a seguir:
for $i in (1, 2, 3) 
where $i < 3 
return <output>{$i}</output>


<output>1</output>
<output>2</output>
order by
Permite ter resultados retornados para especificar. Considere a expressão XQuery simples a seguir e sua saída (que não é classificada de acordo com qualquer ordem especificada pelo usuário):
for $i in (5, 1, 2, 3)
return $i

5
1
2
3

É possível usar a palavra-chave order by para classificar resultados conforme desejado. Este exemplo faz com que resultados sejam retornados em ordem decrescente:

for $i in (5, 1, 2, 3)
order by $i descending 
return $i

5
3
2
1

Suporte do DB2 para XQuery

O DB2 trata XQuery como uma linguagem de primeira classe, permitindo que usuários escrevam expressões XQuery diretamente em vez de requerer que usuários embarquem ou coloquem XQueries nas instruções SQL. O mecanismo de consulta do DB2 processa XQueries de forma nativa, o que significa que analisa, avalia e otimiza XQueries sem jamais convertê-las em SQL em segundo plano. Se quiser, é possível escrever consultas "bilíngues" que incluem expressões XQuery e SQL. O DB2 processará e otimizará essas consultas também.

Para executar uma XQuery diretamente no DB2, você deve usar, como prefácio da consulta, a palavra-chave xquery. Isso instrui o DB2 a chamar seu analisador de XQuery para processar sua solicitação. É necessário fazer isso somente se você estiver usando XQuery como a linguagem mais externa (ou de nível superior). Se você embarcar expressões XQuery em SQL, não é necessário usar como prefácio a palavra-chave xquery .

Neste tutorial, você usará XQuery como a linguagem principal, de forma que todas as consultas mostradas aqui terão como prefácio xquery.


Ambiente do Banco de Dados de Amostra

Para ajudar a aprender XQuery, este tutorial refere-se a uma tabela de amostra "clients" que contém alguns documentos XML. As seções a seguir explicam essa tabela e seu conteúdo em mais detalhes e descrevem os recursos fornecidos pelo DB2 que podem ser usados para emitir XQueries.

Se quiser configurar seu sistema do DB2 para incluir a tabela e o conteúdo de amostra, há um script, tutorial.sql, disponível. Ele contém todo o código mostrado nesta seção.

Tabela de amostra

A tabela clients em nossos exemplos contém colunas baseadas em tipos de dados SQL tradicionais (como cadeias de caracteres de número inteiro e de comprimento variável) e uma coluna baseada no novo tipo de dados "XML" de SQL.

As três primeiras colunas controlam informações sobre IDs, nomes e status de clientes. Valores típicos para a coluna de status incluem Gold, Silver e Standard. A quarta coluna contém as informações de contato de cada cliente, como endereço de correspondência residencial, números de telefones, endereços de e-mail, etc. Essas informações são armazenadas em documentos XML bem formados.

Segue como a tabela clients é definida:

Listagem 9. Definição de tabela clients
create table clients(
id 		int primary key not null, 
name 		varchar(50), 
status 		varchar(10), 
contactinfo 	xml
);

Documentos XML de amostra

Antes de explorar como escrever XQueries com relação a esta tabela, é necessário preenchê-la com alguns dados de amostra. As instruções SQL abaixo inserem seis linhas na tabela clients. Cada linha contém um documento XML e a estrutura de cada documento XML varia um pouco. Por exemplo, endereços de e-mail estão disponíveis para alguns clientes, mas não para outros.

Listagem 10. Dados de amostra para a tabela clients
insert into clients values (3227, 'Ella Kimpton', 'Gold', 
'<Client> 
	<Address>
		<street>5401 Julio Ave.</street>
		<city>San Jose</city>
		<state>CA</state>
		<zip>95116</zip>
	</Address>
	<phone>
		<work>4084630000</work>
		<home>4081111111</home>
		<cell>4082222222</cell>
	</phone>
	<fax>4087776666</fax>
	<email>love2shop@yahoo.com</email>
</Client>'
);


insert into clients values (8877, 'Chris Bontempo', 'Gold', 
'<Client>
	<Address>
		<street>1204 Meridian Ave.</street>
		<apt>4A</apt>
		<city>San Jose</city>
		<state>CA</state>
		<zip>95124</zip>
	</Address>
	<phone>
		<work>4084440000</work>
	</phone>
	<fax>4085555555</fax>
</Client>'
);


insert into clients values (9077, 'Lisa Hansen', 'Silver', 
'<Client>
	<Address>
		<street>9407 Los Gatos Blvd.</street>
		<city>Los Gatos</city>
		<state>CA</state>
		<zip>95032</zip>
	</Address>
	<phone>
		<home>4083332222</home>
	</phone>
</Client>'
);


insert into clients values (9177, 'Rita Gomez', 'Standard', 
'<Client>
	<Address>
		<street>501 N. First St.</street>
		<city>Campbell</city>
		<state>CA</state>
		<zip>95041</zip>
	</Address>
	<phone>
		<home>4081221331</home>
		<cell>4087799881</cell>
	</phone>
	<email>golfer12@yahoo.com</email>
</Client>'
);


insert into clients values (5681, 'Paula Lipenski', 'Standard', 
'<Client>
	<Address>
		<street>1912 Koch Lane</street>
		<city>San Jose</city>
		<state>CA</state>
		<zip>95125</zip>
	</Address>
	<phone>
		<cell>4085430091</cell>
	</phone>
	<email>beatlesfan36@hotmail.com</email>
	<email>lennonfan36@hotmail.com</email>
</Client>'
); 


insert into clients values (4309, 'Tina Wang', 'Standard', 
'<Client>
	<Address>
		<street>4209 El Camino Real</street>
		<city>Mountain View</city>
		<state>CA</state>
		<zip>95033</zip>
	</Address>
	<phone>
		<home>6503310091</home>
	</phone>
</Client>'
);

Ambiente de consulta

Todas as consultas deste tutorial são projetadas para serem emitidas de forma interativa. É possível fazer isso por meio do processador de linha de comando do DB2 ou do DB2 Command Editor do DB2 Control Center. Exemplos deste tutorial usam o processador de linha de comando do DB2. (O DB2 também é enviado com um Developer Workbench baseado no Eclipse que pode ajudar construir graficamente XQueries, mas a discussão do Developer Workbench está além do escopo deste tutorial.)

É possível alterar configurações padrão para o processador de linha de comando do DB2 para facilitar o trabalho com dados XML. Por exemplo, o comando a seguir (emitido de uma janela de comando do DB2) ativará o processador de comandos do DB2 de maneira que fará com que os resultados de XQuery sejam exibidos em um formato que seja fácil de ler:

Listagem 11. Configurando opções de processamento de linha de comando do DB2
db2 -i -d

Esse comando faz com que o DB2 inclua espaços em branco extras nos resultados exibidos de XQueries. O DB2 não inclui realmente esses espaços em branco em seus dados. Seus aplicativos não verão itens retornados com espaços brancos extras -- eles estarão visíveis somente da janela do processador de linha de comando do DB2.


Operações de Recuperação de Dados XML Simples

Nesta seção, você aprenderá como gravar XQueries que recuperam documentos XML inteiros e partes (ou fragmentos) específicos de documentos XML. Para fazer isso, você usará expressões XPath e expressões FLWOR.

Recuperando documentos XML integrais armazenados no DB2

Ao executar como uma linguagem de nível superior, XQuery precisa ter uma fonte de dados de entrada. No DB2, uma maneira que é possível especificar essa fonte de entrada de dados é chamando uma função denominada db2-fn:xmlcolumn. Essa função aceita um parâmetro de entrada que identifica a tabela do DB2 e o nome da coluna XML de interesse. A função db2-fn:xmlcolumn retorna a sequência de documentos XML armazenados na coluna determinada. Por exemplo, a consulta a seguir retorna uma sequência de documentos XML contendo informações e contato do cliente:

Listagem 12. XQuery simples para retornar dados de contato do cliente
xquery 
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')

Você pode estar se questionando por que os nomes da tabela e da coluna especificados nesta consulta estão em maiúsculas. Se você se lembrar da instrução SQL usada anteriormente para criar essa tabela, você sabe que os nomes da tabele e da coluna foram escritos em minúsculas. A menos que especificar o contrário, o DB2 converte em letras maiúsculas os nomes de tabelas e colunas em seu catálogo interno. Como XQuery faz distinção entre maiúsculas e minúsculas, os nomes de tabelas e colunas em minúsculas falhariam em corresponder a nomes em maiúsculas no catálogo do DB2.

Agora, vamos considerar a saída dessa XQuery. Considerando os dados de amostra inseridos na tabela clients, a saída da consulta na Listagem 12 é uma sequência de seis documentos XML, conforme mostrado abaixo.

Listagem 13. Saída da consulta anterior
<?xml version="1.0" encoding="windows-1252" ?>
<Client>
	<Address>
		<street>
			5401 Julio Ave.
		</street>
		<city>
			San Jose
		</city>
		<state>
			CA
		</state>
		<zip>
			95116
		</zip>
	</Address>
	<phone>
		<work>
			4084630000
		</work>
		<home>
			4081111111
		</home>
		<cell>
			4082222222
		</cell>
	</phone>
	<fax>
		4087776666
	</fax>
	<email>
		love2shop@yahoo.com
	</email>
</Client>
<?xml version="1.0" encoding="windows-1252" ?>
<Client>
	<Address>
		<street>
			1204 Meridian Ave.
		</street>
		<apt>
			4A
		</apt>
		<city>
			San Jose
		</city>
		<state>
			CA
		</state>
		<zip>
			95124
		</zip>
	</Address>
	<phone>
		<work>
			4084440000
		</work>
	</phone>
	<fax>
		4085555555
	</fax>
</Client>
<?xml version="1.0" encoding="windows-1252" ?>
<Client>
	<Address>
		<street>
			9407 Los Gatos Blvd.
		</street>
		<city>
			Los Gatos
		</city>
		<state>
			CA
		</state>
		<zip>
			95032
		</zip>
	</Address>
	<phone>
		<home>
			4083332222
		</home>
	</phone>
</Client>
<?xml version="1.0" encoding="windows-1252" ?>
<Client>
	<Address>
		<street>
			501 N. First St.
		</street>
		<city>
			Campbell
		</city>
		<state>
			CA
		</state>
		<zip>
			95041
		</zip>
	</Address>
	<phone>
		<home>
			4081221331
		</home>
		<cell>
			4087799881
		</cell>
	</phone>
	<email>
		golfer12@yahoo.com
	</email>
</Client>
<?xml version="1.0" encoding="windows-1252" ?>
<Client>
	<Address>
		<street>
			1912 Koch Lane
		</street>
		<city>
			San Jose
		</city>
		<state>
			CA
		</state>
		<zip>
			95125
		</zip>
	</Address>
	<phone>
		<cell>
			4085430091
		</cell>
	</phone>
	<email>
		beatlesfan36@hotmail.com
	</email>
	<email>
		lennonfan36@hotmail.com
	</email>
</Client>
<?xml version="1.0" encoding="windows-1252" ?>
<Client>
	<Address>
		<street>
			4209 El Camino Real
		</street>
		<city>
			Mountain View
		</city>
		<state>
			CA
		</state>
		<zip>
			95033
		</zip>
	</Address>
	<phone>
		<home>
			6503310091
		</home>
	</phone>
</Client>

Caso esteja curioso, também é possível usar SQL simples para recuperar o conjunto integral de documentos XML contidos na coluna contactinfo . A instrução simples "select contactinfo from client" fará isso.

Recuperando elementos XML específicos

Frequentemente, usuários desejam recuperar elementos específicos de documentos XML. Fazer isso com XQuery pode ser simples. Imaginemos que você deseje recuperar os números de fax de todos os clientes que forneceram essa informação. Segue uma maneira para escrever essa consulta:

Listagem 14. Expressão FLWOR para recuperar dados de fax do cliente
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/fax
return $y

A primeira linha instrui o DB2 a chamar seu analisador de XQuery. A próxima linha instrui o DB2 para iterar por meio dos subelementos fax dos elementos Client contidos na coluna CLIENTS.CONTACTINFO. Cada elemento fax é ligado, por sua vez, à variável $y. a terceira linha indica que, para cada iteração, o valor de $y é retornado. O resultado é uma sequência de elementos XML, conforme mostrado abaixo.

Listagem 15. Saída de amostra para consulta anterior
<fax>4087776666</fax>
<fax>4085555555</fax>

(A saída mostrada é um tanto quanto simplificada. As informações de versão de XML foram removidas, pois não é importante para esta tutorial. No entanto, XQueries executadas no DB2 retornarão tais informações. Consulte a Listagem 13 para obter um exemplo.)

A consulta mostrada na Listagem 14 também poderia ser expressa simplesmente como uma expressão de caminho em três etapas:

Listagem 16. Expressão de caminho para recuperar dados de fax do cliente
xquery 
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/fax

Em Fundamentos de XQuery você aprendeu sobre nós de texto. Vamos aplicar esse conhecimento aqui. Imagine que você não queira obter fragmentos de XML de sua consulta, mas deseje,em vez disso, apenas uma representação de texto de valores de elementos XML de qualificação. Para fazer isso, é possível chamar a função text() em sua cláusula return :

Listagem 17. Duas consultas para recuperar representação de texto dos dados de fax do cliente
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/fax
return $y/text()

(ou)

xquery
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/fax/text()

A saída dessas consultas é:

Listagem 18. Saída de amostra de consultas anteriores
4087776666
4085555555

Os resultados das consultas anteriores nesta seção são relativamente simples, pois envolvem o elemento fax, que é baseado em um tipo de dados primitivo. É claro, elementos podem ser baseados em tipos complexos, contendo subelementos (ou hierarquias aninhadas). O elemento Address de nossas informações de contato do cliente é um exemplo disso. Considere o que a XQuery a seguir retornará:

Listagem 19. XQueries para recuperar tipo XML complexo
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/Address
return $y

(ou)

xquery
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/Address

Se tiver apostado em uma sequência de fragmentos XML contendo elementos Address e todos os seus subelementos, você está certo. Segue um trecho da saída:

Listagem 20. Saída parcial da consulta anterior
<Address>
  <street>5401 Julio Ave.</street>
  <city>San Jose</city>
  <state>CA</state>
  <zip>95116</zip>
</Address>
<Address>
  <street>1204 Meridian Ave.</street>
  <apt>4A</apt>
  <city>San Jose</city>
  <state>CA</state>
  <zip>95124</zip>
</Address>
<Address>
   <street>9407 Los Gatos Blvd.</street>
   <city>Los Gatos</city>
   <state>CA</state>
   <zip>95032</zip>
</Address>
	
. . .

Consultas que Filtram por Valores de Elementos XML

Usuários frequentemente especificam critérios de filtragem baseados em XML em suas XQueries. E isso é fácil de fazer. Nesta seção, você verá como tornar alguns exemplos XQuery anteriores mais seletivos.

Especificando um único predicado de filtragem

Vamos começar explorando como retornar os endereços de correspondência de todos os clientes que vivem no CEP 95116. É possível incorporar uma cláusula where em sua XQuery para filtrar resultados com base no valor do elemento zip nos documentos XML de amostra armazenados no DB2. Para incluir uma cláusula where na expressão FLWOR na Listagem 19 para obter somente os endereços de interesse:

Listagem 21. Expressão FLWOR como uma nova cláusula "where"
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/Address
where $y/zip="95116"
return $y

A cláusula where incluída é bem simples. A cláusula for liga a variável $y a cada endereço. A cláusula where contém uma pequena expressão de caminho que navega a partir da cada endereço para seu elemento zip aninhado. A cláusula where é verdadeira (e o endereço é retido) somente se o valor desse elemento zip for igual a 95116.

Como somente um cliente vive no CEP de destino, o resultado retornado é:

Listagem 22. Saída da consulta anterior
<Address>
  <street>5401 Julio Ave.</street>
  <city>San Jose</city>
  <state>CA</state>
  <zip>95116</zip>
</Address>

O mesmo resultado poderia ser obtido incluindo-se um predicado na expressão de caminho, da seguinte forma:

Listagem 23. Expressão de caminho com predicado de filtragem adicional
xquery
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/Address[zip="95116"]

Especificando diversos predicados de filtragem

É claro que é possível filtrar por valores de CEP e retornar elementos não relacionados a endereços de rua. Também é possível filtrar valores de elementos XML em uma única consulta. A consulta a seguir retorna informações de e-mail para clientes que vivem em qualquer lugar da cidade de San Jose ou no CEP 95032 (que é um CEP em Los Gatos, Califórnia).

Listagem 24. Filtragem por diversos valores de elementos XML com uma expressão FLWOR
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client
where $y/Address/zip="95032" or $y/Address/city="San Jose"
return $y/email

Este exemplo altera a cláusula for de forma que ligue a variável $y a elementos Client em vez de a elementos Address. Isso permite filtrar os elementos Client por uma parte da subárvore (Address) e retornar outra parte da subárvore (email). As expressões de caminho na cláusula where e na cláusula return devem ser escritas com relação ao elemento ligado à variável (neste caso, $y).

A mesma consulta poderia ser expressa de forma um tanto quando mais concisa como uma expressão de caminho:

Listagem 25. Filtragem por diversos valores de elementos XML com uma expressão de caminho
xquery 
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client[Address/zip="95032"  
or Address/city="San Jose"]/email;

Considerando os dados de amostra na tabela clients, a saída de qualquer uma dessas duas consultas anteriores é:

Listagem 26. Saída da consulta
<email>
	love2shop@yahoo.com
</email>
<email>
	beatlesfan36@hotmail.com
</email>
<email>
	lennonfan36@hotmail.com
</email>

Um exemplo prático de como XQuery e SQL diferem

Se você inspecionar a saída da consulta na Listagem 26, poderá descobrir que os resultados retornados diferem em duas maneiras significativas do que um programador de SQL poderia esperar:

  • Nenhum dado XML é retornado para qualificar clientes que não forneceram seus endereços de e-mail.

    Considerando nossos dados de amostra, quatro clientes atendem nossos critérios de seleção (eles vivem em San Jose ou no CEP 95032), ainda assim esse fato não é refletido nos resultados da consulta. Por quê? Os elementos email estão ausentes para dois desses registros de clientes. Como XQuery não usa nulos, essas informações "ausentes" não são refletidas nos resultados.

  • A saída não indica quais endereços de e-mail foram derivados do mesmo documento XML.

    Uma olhada de perto nos dados de amostra indica que os dois endereços de e-mail finais mostrados na Listagem 26 estão contidos em um documento XML (ou seja, pertencem a um cliente). Isso não está óbvio a partir da saída.

Ambas as situações podem ser desejáveis sob algumas circunstâncias e indesejáveis sobre outras. Por exemplo, se quiser enviar um e-mail a cada conta qualificada no registro, então, iterar por meio de uma lista de endereços de e-mails de clientes no formato XML é fácil de fazer em um aplicativo. No entanto, se quiser enviar por correio somente um aviso a cada cliente -- inclusive àqueles que forneceram somente endereços de rua -- então, as XQueries mostradas anteriormente não são suficientes.

Há diversas maneiras para reescrever as consultas anteriores de forma que os resultados retornados representem informações ausentes de alguma maneira e indiquem quando diversos endereços de e-mail tiverem derivado do mesmo registro de cliente (ou seja, o mesmo documento XML). Você aprenderá como fazer isso um pouco depois neste tutorial. No entanto, se quiser apenas recuperar uma lista contendo um endereço de e-mail por cliente qualificado, você poderia modificar as consultas anteriores ligeiramente:

Listagem 27. Retornando o primeiro elemento de e-mail de clientes qualificados
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client
where $y/Address/zip="95032" or $y/Address/city="San Jose"
return $y/email[1]

(ou)

xquery 
db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client[Address/zip="95032"  
or Address/city="San Jose"]/email[1];

Ambas as consultas instruem o DB2 a retornar o primeiro elemento email que localizar dentro de cada documento XML qualificado (registro de contato do cliente). Se não localizar um endereço de e-mail para um cliente qualificado, não retornará nada para esse cliente. Assim, ambas as consultas produzem esta saída:

Listagem 28. Saída da consulta
<email>
	love2shop@yahoo.com
</email>
<email>
	beatlesfan36@hotmail.com
</email>

Transformações de Dados XML

Um aspecto eficiente de XQuery é sua capacidade de transformar dados XML e uma forma de XML em outra. Nesta seção, você aprenderá como é fácil fazer isso.

Convertendo XML em HTML

Nos aplicativos baseados na Web, é comum converter todos ou parte dos documentos XML em HTML para fácil exibição. Com XQuery, esse processo é direto. Considere a consulta a seguir, que recupera os endereços de clientes, classifica os resultados por CEP e converte a saída em elementos XML que fazem parte de uma lista HTML não ordenada:

Listagem 29. Consultando dados XML do DB2 e retornando resultados como HTML
xquery 
<ul> {
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client/Address
order by $y/zip
return <li>{$y}</li> 
} </ul>

A consulta começa de forma bastante simples com a palavra-chave xquery para indicar ao analisador do DB2 que XQuery está sendo usada como a linguagem principal. A s segunda linha faz com que a marcação HTML de uma lista não ordenada (<ul>) seja incluída nos resultados. Também apresenta chaves, o primeiro de dois conjuntos usados nesta consulta. Chaves instruem o DB2 a avaliar e processar a expressão entre chave em vez de tratá-la como uma cadeia de caractere literal.

A terceira linha itera sobre endereços de clientes, ligando a variável $y a cada elemento Address. A quarta linha inclui uma cláusula order by , especificando que resultados devem ser retornados em ordem crescente (a ordem padrão) com base em CEPs (o subelemento zip de cada Address ligado a $y). A cláusula return indica que os elementos Address devem estar entre tags de itens de lista HTML antes do retorno. E a linha final conclui a consulta e completa a tag da lista não ordenada de HTML.

Uma parte da saída resultante dessa consulta é:

Listagem 30. Saída HTML da consulta anterior
<ul>
  <li>
     <Address>
         <street>9407 Los Gatos Blvd.</street>
         <city>Los Gatos</city>
         <state>CA</state>
         <zip>95032</zip>
     </Address>
  </li>
  <li>
     <Address>
         <street>4209 El Camino Real</street>
         <city>Mountain View</city>
         <state>CA</state>
        <zip>95033</zip>
     </Address>
  </li>
. . . 
</ul>

Usando transformações para indicar elementos ausentes ou repetidos em documentos XML

Vamos considerar um tópico levantado anteriormente: como gravar uma XQuery que indicará valores ausentes nos resultados retornados e indicará quando um único documento XML (como um único registro de cliente) contém elementos repetidos, como diversos endereços de e-mail. Uma maneira de fazer isso envolve agrupar a saída retornada em um novo elemento XML, conforme mostrado na consulta a seguir:

Listagem 31. Indicando valores ausentes e elementos repetidos em um resultado de XQuery
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client
where $y/Address[zip="95032"] or $y/Address[city="San Jose"]
return <emailList> {$y/email} </emailList>

A execução dessa consulta faz com que uma sequência de elementos emailList sejam retornados, um por cada registro de cliente qualificado. Cada elemento emailList conterá dados de e-mail. Se o DB2 localizar um único endereço de e-mail, retornará esse elementos e seu valor. Se localizar diversos endereços de e-mail, retornará todos os elementos de e-mail e seus valores. Por fim, se não localizar nenhum endereço de e-mail, retornará um elemento emailList vazio.

Considerando nossos dados de amostra, a saída dessa consulta é:

Listagem 32. Saída da consulta anterior
<emailList>
   <email>love2shop@yahoo.com</email>
</emailList>
<emailList/>
<emailList/>
<emailList>
   <email>beatlesfan36@hotmail.com</email>
   <email>lennonfan36@hotmail.com<emailList>
</emailList>

Lógica Condicional

É possível incorporar lógica condicional em suas XQueries usando algumas palavras-chave simples.

Imagine que você gostaria de contatar cada um de seus clientes. Você preferiria contatá-los por e-mail, mas se não tiver um endereço de e-mail, então deseja ligar para eles em casa. Se não tiver um telefone residencial também, deseja enviar uma carta por correio postal a eles. Assim, é necessário consultar sua tabela clients do DB2 e montar uma lista de contatos que possa conter um único endereço de e-mail, número de telefone residencial ou endereço de correspondência postal para cada um de seus clientes.

Esta tabela é fácil de realizar se você incorporar a lógica condicional em sua XQuery. Segue uma maneira de obter as informações necessárias:

Listagem 33. XQuery com uma expressão condicional em três partes
xquery 
for $y in db2-fn:xmlcolumn('CLIENTS.CONTACTINFO')/Client 
return ( 
  if ($y/email) then $y/email[1] 
  else if ($y/phone/home) then <homePhone>{$y/phone/home/text()}</homePhone>
  else $y/Address)

Vamos dar uma olhada nas linhas 4 a 6 desta consulta. Como é possível ver, elas fazem parte da cláusula return e determinam a saída da consulta.

A linha 4 testa se pelo menos um elemento email está presente no documento; se estiver, especifica que o primeiro elemento email deve ser retornado. Se nenhum elemento email estiver presente, a linha 5 é executada. Instrui o DB2 a tentar localizar um elemento home abaixo do elemento phone. Se um número de telefone residencial for incluído no documento, seu nó de texto é extraído e retornado como parte de um novo elemento "homePhone". Por fim, se nem um endereço de e-mail nem um número de telefone residencial estiver presente o perfil do cliente (documento XML), o DB2 retorna o elemento Address integral. Como todos os registros da tabela clients incluem um endereço de correspondência postal, a lógica dessa consulta assegura que o DB2 retornará uma maneira de contatar cada cliente.

A saída dessa consulta é:

Listagem 34. Saída da consulta
<email>
	love2shop@yahoo.com
</email>

<Address>
	<street>
		1204 Meridian Ave.
	</street>
	<apt>
		4A
	</apt>
	<city>
		San Jose
	</city>
	<state>
		CA
	</state>
	<zip>
		95124
	</zip>
</Address>

<homePhone>
	4083332222
</homePhone>

<email>
	golfer12@yahoo.com
</email>

<email>
	beatlesfan36@hotmail.com
</email>

<homePhone>
	6503310091
</homePhone>

Consultas "híbridas"

Você viu como escrever XQueries que recuperam fragmentos de documentos XML, criar ovas formas de saída de XML e retornar saída diferente com base em condições especificadas nas próprias consultas. Essas são algumas maneiras simples de consultar dados XML armazenados no DB2.

Com certeza há mais a se aprender sobre XQuery do que este tutorial discuta. Mas há um tópico amplo que não podemos negligenciar: como escrever consultas que incluam expressões SQL e XQuery. Fazer isso pode ser útil se precisar gravar consultas que filtrem dados com base em valores de coluna XML e não XML.

Como este tutorial foca XQuery e seu uso como uma linguagem de nível superior, vamos primeiramente explorar como embarcar SQL em XQueries. No entanto, 'e importante observar que também é possível fazer o oposto -- é possível embarcar XQueries em SQL. Você também verá um exemplo em síntese de como fazer isso no final deste tutorial. No entanto, para obter informações adicionais sobre SQL/XML e como embarcar XQueries em SQL, consulte Recursos.

Embarcando SQL em XQueries

Para embarcar SQL em uma XQuery, você usa a função db2-fn:sqlquery no lugar da função db2-fn:xmlcolumn . A função db2-fn:sqlquery executa uma consulta SQL e retorna somente os dados selecionados. A consulta SQL passada a db2-fn:sqlquery deve retornar somente dados XML; isso possibilita que XQuery processe ainda mais o resultado da consulta SQL.

Vamos usar um exemplo que incorpore muitos conceitos que já cobrimos. Imagine que você deseje uma lista de todos os endereços de e-mail para clientes Gold que vivem em San Jose. Se um cliente tiver diversos endereços de e-mail, você deseja que todos eles sejam incluídos na saída como parte de um único registro. Por fim, se um cliente Gold qualificado não tiver fornecido um endereço de e-mail, você deseja recuperar seu endereço de correspondência postal. Segue uma maneira para escrever essa consulta:

Listagem 35. Embarcando SQL dentro de uma XQuery que inclui lógica condicional
xquery 
for $y in 
db2-fn:sqlquery('select contactinfo from clients where status=''Gold'' ')/Client
where $y/Address/city="San Jose"
return (
     if ($y/email) then <emailList>{$y/email}</emailList>
     else $y/Address   
)

Vamos focar a terceira linha, que embarca uma instrução SQL. A instrução SELECT contém um predicado de consulta com base na coluna status , comparando o valor dessa coluna VARCHAR à cadeia de caractere Gold. Em SQL, tais cadeias de caracteres estão entre aspas simples. Apesar de o exemplo poder parecer usar aspas duplas, na verdade usa duas aspas simples antes e depois do valor de comparação (''Gold''). As aspas simples "extras" são caracteres de escape. Se usar aspas duplas em torno de seu predicado de consulta baseado em cadeia de caracteres, em vez de pares de aspas simples, obterá um erro de sintaxe.

A saída dessa consulta é:

Listagem 36. Saída da consulta
<emailList>
	<email>
		love2shop@yahoo.com
	</email>

<Address>
	<street>
		1204 Meridian Ave.
	</street>
	<apt>	4A
	</apt>
	<city>
		San Jose
	</city>
	<state>
		CA
	</state>
	<zip>
		95124
	</zip>
</Address>

Embarcando XQueries em SQL

É importante entender que também é possível embarcar XQueries em SQL. Na verdade, o DB2 9 apresenta suporte para funções SQL/XML padrão que são frequentemente usadas para formular consultas híbridas em que SQL é a linguagem mais externa (ou de nível superior). Apesar de estar além do escopo deste tutorial discutir o suporte a SQL/XML do DB2 em detalhes, pelo menos duas funções valem a pena ser observadas especificamente:

XMLExists
Permite navegar até um elemento (ou outro tipo de nó) dentro de seu documento XML e testar uma condição específica. Quando especificado como parte da cláusula WHERE SQL, XMLExists restringe os resultados retornados a somente àquelas linhas que contêm um documento XML que satisfaz sua condição especificada (quando a condição especificada é avaliada como "true"). Como é possível suspeitar, você passa uma expressão XQuery como entrada na função XMLExists para navegar até o nó de interesse em seu documento.
XMLQuery
Permite projetar XML no conjunto de resultados SQL retornado de sua consulta SQL/XML. É comumente usado para recuperar um ou mais elementos de documentos XML. Novamente, como é possível imaginar, a função XMLQuery aceita uma expressão XQuery como entrada.

Considere a consulta a seguir, que usa SQL como a linguagem de nível superior e inclui chamadas nas funções XMLQuery e XMLExists :

Listagem 37. Embarcando expressões de caminho XQuery em SQL para projetar e restringir dados XML
select name, status,
xmlquery('$c/Client/phone/home' passing contactinfo as "c") 
from clients 
where xmlexists('$y/Client/Address[zip="95032"]' passing contactinfo as "y")

Essa consulta retorna um conjunto de resultados com colunas para o nome, status e número de telefone residencial do cliente. As duas primeiras colunas contêm dados SQL VARCHAR e a terceira coluna contém um elemento XML extraído de documentos XML qualificados. Vamos considerar as linhas 2 e 4 desta consulta mais de perto.

A linha 2 chama XMLQuery como parte da cláusula SELECT , indicando que o resultado retornado por essa função deve ser incluído como uma coluna no conjunto de resultados SQL. Como entrada para essa função, especificamos uma expressão de caminho XQuery que faz com que o DB2 navegue até o subelemento home do elemento phone diretamente abaixo do elemento Client. A expressão de caminho faz referência a uma variável ($c), que declaramos para fazer referência à coluna contactinfo.

A linha 4 chama XMLExists dentro de uma cláusula WHERE SQL, indicando que o DB2 deve restringir os resultados com base em um predicado XML. Esse predicado é especificado na expressão de caminho -- indica que estamos interessados somente em clientes que vivem em um CEP específico. Novamente, você observará que a expressão de caminho fornecida como entrada para essa função SQL/XML define uma variável ($y, neste caso) que identifica onde o DB2 localizará os documentos XML de interesse -- na coluna contactinfo.

Considerando nossos dados de amostra, a saída dessa consulta é um conjunto de resultados de linha única com os seguintes valores:

Listagem 38. Saída da consulta
Lisa Hansen         Silver    <home>4083332222</home>

Para obter informações adicionais sobre o suporte a SQL/XML do DB2, consulte Recursos.


Resumo

Este tutorial apresentou o suporte a XQuery do DB2 e explicou diversos conceitos básicos da linguagem. Você aprendeu como escrever e executar XQueries simples com relação a dados XML armazenados no DB2.

Para ficar de olho nesta série, marque a página da série, série de tutoriais de preparação para o exame 730 DB2 9 Fundamentals.

Recursos

Aprender

Obter produtos e tecnologias

  • Uma versão de avaliação do DB2 9 está disponível para download gratuito.
  • Faça o download do DB2 Express-C, uma versão gratuita do DB2 Express Edition para a comunidade que oferece os mesmos recursos de dados centrais que o DB2 Express Edition e fornece uma base sólida para desenvolver e implementar aplicativos.

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Information Management
ArticleID=757166
ArticleTitle=Preparação para o Exame 730 DB2 9 Fundamentals, Parte 7: Apresentando XQuery
publish-date=09162011