Criação de um aplicativo JSON e pureXML, Parte 1: Armazenar e consultar o JSON com o DB2 pureXML

Adotar um mapeamento simples do JSON para XML

O JavaScript Object Notation (JSON), notação textual popular na Web 2.0, é utilizado para representar objetos (ou estruturas de dados), como texto serializado no intercâmbio de informações entre clientes e servidores. Alguns aplicativos se beneficiam dos persistentes objetos JSON para manter o estado através das sessões. Neste artigo, aprenda como o DB2® pureXML® pode armazenar, gerenciar e consultar o JSON quando se adota um simples mapeamento do JSON para XML.

Nuno Job, CoOp: DB2 Technical Enablement Specialist, IBM  

Photo of Nuno JobNuno Job é um estudante de mestrado da Universidade de Minho que realizou um estágio na IBM no T.J. Watson Research Center, na equipe de habilitação para o pureXML. Entre suas áreas de interesse encontramos tecnologias de código aberto, Linux, segurança, privacidade, Web e bancos de dados hierárquicos. Atualmente, Nuno está trabalhando na IBM em Toronto como DB2 Technical Enablement Specialist, auxiliando os clientes a obter a validação nos programas de parceiros da IBM e mantendo um IBM Ruby no aplicativo Rails.



Susan Malaika, Senior Technical Staff Member, IBM

Susan Malaika photoSusan Malaika é Membro Senior da Equipe Técnica no IBM Information Management Group (parte do IBM Software Group). Suas especialidades incluem XML, Web e bancos de dados. Ela desenvolveu padrões que suportam dados para ambientes de grade no Global Grid Forum. Além de trabalhar como desenvolvedora de software de produtos IBM, ela também trabalhou como especialista em Internet, analista de dados e editora e desenvolvedora de telas. Susan também é coautora de um livro sobre a Web e publicou artigos sobre processamento de transações e XML. Ela é membro da IBM Academy of Technology.



Michael Schenker, Software Engineer, IBM

Author Photo: Michael SchenkerMichael Schenker possui mestrado em ciência da computação pela University of Applied Science, em Leipzig/Alemanha. Ele tem sete anos de experiência profissional na IBM. Durante sua carreira, Michael trabalhou em diversos produtos relacionados a banco de dados, começando como estagiário para trabalhar em DB2 Information Integration com foco em wrappers não relacionais. Ele se uniu à IBM como funcionário em tempo integral no final de 2003. Em 2006, Michael juntou-se à organização de ferramentas de banco de dados e trabalhou na funcionalidade de provedor de serviços da Web do DB2 no IBM Data Studio Developer. Ele ganhou muita experiência em SOA e tecnologias da Web durante esse tempo. Recentemente, Michael uniu-se à equipe de otimização de DB2 para z/OS, mas ainda tem interesse em SOA e tecnologias da Web em (e relacionadas a) DB2.



27/Nov/2009 (Primeira publicação 27/Nov/2009)

Introdução

O JavaScript (definido no ECMAScript Language Specification no ECMA) é uma linguagem de script implementada pela primeira vez no Netscape Navigator (um navegador da Web) para aprimorar o processamento de páginas da Web. O JSON (definido em RFC 4627 no IETF) é um formato que representa estruturas de dados em JavaScript, tais como objetos e arrays, como texto serializado.

Termos frequentemente usados

  • Ajax: Asynchronous JavaScript + XML
  • API: Application programming interface
  • DBMS: Database Management System
  • DOM: Document Object Model
  • HTTP: Hypertext Transfer Protocol
  • IETF: Internet Engineering Task Force
  • RFC: Request For Comments
  • RSS: Really Simple Syndication
  • SAX: Simple API for XML
  • SOA: Service Oriented Architecture
  • W3C: World Wide Web Consortium
  • XHTML: Extensible HyperText Markup Language
  • XML: Extensible Markup Language
  • XSLT: Extensible Stylesheet Language Transformations

Enquanto o XML (definido na especificação XML 1.0 no W3C) é uma representação comum para troca de mensagens entre clientes e servidores fracamente acoplados, o JSON é frequentemente usado para atingir o mesmo efeito. Uma das razões para adoção do JSON é que os seus objetos são fáceis de manipular usando linguagens de script, tais como JavaScript, Python ou Ruby.

A ideia de armazenar e consultar XML em bancos de dados surgiu depois que o XML para intercâmbio de dados prevaleceu sobre os demais. Da mesma forma, a manipulação e intercâmbio do JSON se tornou comum, mas não para armazenagem ainda. No entanto, sistemas de gerenciamento de banco de dados orientados a documentos JSON começaram a surgir. Por exemplo, o Apache CouchDB é fortemente alinhado com o JSON através de suas interfaces e armazenamento.

Neste artigo apresentamos a noção de intercâmbio do JSON como XML, de modo a aproveitar os processadores, dispositivos e armazenamento XML (normalmente presente em bancos de dados XML, tais como DB2 pureXML) e outras tecnologias XML como o XQuery e XSLT. Para conseguir isso, apresentamos um formato de XML chamado JSONx, descrevemos uma notação amigável de JSON para XML e explicamos as diferenças entre o JSONx e formatos amigáveis.

Seguindo essas etapas no artigo e no respectivo download, pode-se criar um armazenamento JSON consultável e indexável baseado no banco de dados de amostra DB2 pureXML. Este artigo é o primeiro de uma série de três artigos que ilustra como criar um aplicativo pureXML de três camadas baseado em JSON incorporando o JSON, serviços da Web e dispositivos OpenSocial.

Figura 1. Visão geral da arquitetura Universal Services
Visão geral da arquitetura Universal Services

O Universal Services é um conjunto simples, mas fixo, de operações de banco de dados que permite consultar e modificar dados XML, armazenado em uma coluna pureXML de um banco de dados DB2. Essas operações de banco de dados permitem inserir, atualizar, excluir e consultar dados expostos como serviços da Web através do mecanismo Data Web Service. Consulte Recursos para mais informações sobre o Universal Services para pureXML. O JSON Universal Services para pureXML expõe as mesmas operações de banco de dados para clientes, mas em JSON ao invés de XML, e continua a trabalhar com XML no lado do servidor. O aplicativo cliente não sabe que o JSON de chegada e saída está sendo convertido para XML no lado do servidor no banco de dados.

Este artigo também explora as opções que podem ser escolhidas para representar JSON como XML e descreve alguns cenários e como o pureXML do IBM DB2 pode ser aplicado nesses cenários. O artigo contém um download (chamado de pacote configurável JSONx), que pode ser usado para criar uma amostra de banco de dados pureXML JSONx. Ele cria uma base para aplicativos JSONx. Estão incluídas no download duas funções definidas pelo usuário em DB2 que fazem a conversão entre JSON e JSONx e vice-versa.

JSON

O JSON é um formato legível baseado em texto que é usado para intercâmbio de dados entre clientes e servidores. Ele fornece aos desenvolvedores um formato de intercâmbio que mapeia diretamente para as estruturas de dados que eles usam. Para fazer isso, o JSON define as seguintes estruturas de dados principais: número, cadeia de caractere, variáveis booleanas (verdadeiro e falso), array (uma sequência ordenada de valores), objeto (coleção de pares de valores principais) e nulo.

A Listagem 1 ilustra um objeto JSON que descreve um cliente. Aninhado dentro do objeto customerinfo estão dois objetos que definem o ID (cid) e o nome do cliente. O objeto customerinfo também contém dois objetos estruturados para definir o endereço e os números de telefone do cliente.

Listagem 1. Informações do cliente para Kathy Smith em JSON
{
  "customerinfo" : {
	"cid" : 1000 ,
	"name" : "Kathy Smith" ,
	"addr" : {
	  "country"    : "Canada" ,
	  "street"     : "5 Rosewood" ,
	  "city"       : "Toronto" ,
	  "prov-state" : "Ontario" ,
	  "pcode-zip"  : "M6W 1E6"
	} ,
	"phone" : {
	  "work" : "416-555-1358"
	}
  }
}

Um cenário típico de JSON

Um caso de uso típico do JSON é ter um aplicativo da Web trocando dados com uma API como o Yahoo Web Services ou o Twitter API. Neste cenário, um aplicativo da Web usa os pedidos assíncronos de JavaScript (Ajax) para comunicar o JSON com o serviço da Web que expõe a API.

Frequentemente, essa API permite que o aplicativo escolha o formato de intercâmbio. Os formatos comuns suportados incluem XML, padrões XML pré-definidos, tais como RSS e Atom, e JSON. Para exemplos desses formatos, consulte o Anexo A.

A liberdade de escolha do formato usado para comunicação entre o aplicativo e o serviço da Web possibilita aos desenvolvedores acelerar o processo de desenvolvimento. Entretanto, isso levanta questões relativas à manutenção de uma infraestrutura que suporte múltiplos formatos simultaneamente. A lista abaixo inclui algumas das opções para armazenamento de dados:

  • Usar um banco de dados JSON de centralização de documentos como o Apache CouchDB.
  • Usar um banco de dados relacional para fragmentar e reconstruir JSON para cada pedido.
  • Usar armazenamento nativo XML (armazenando JSONx) e oferecer interfaces que exponham e processem JSON.

A Figura 2 ilustra exemplos para cada uma dessas opções de armazenamento de dados. (Visualize uma versão ampliada da Figura 2.)

Figura 2. Modos diferentes para armazenar JSON
Modos diferentes para armazenar JSON

Todas essas abordagens têm seus pontos fortes e fracos. Este artigo não analisa essas diferenças, mas se concentra no cenário em que o uso do pureXML é a abordagem mais conveniente para um aplicativo específico. Algumas razões que fazem com que o XML seja a abordagem mais conveniente são:

  • O restante da infraestrutura já está usando XML e SOA
  • A existência de dispositivos XML (tais como IBM Websphere® DataPower®) e tecnologias XML que podem ser estendidas para trabalhar com JSONx

Contraste entre JSON e XML

Quando os desenvolvedores usam XML para intercâmbio, geralmente navegam pelo XML através do XML DOM ou SAX. A capacidade de trabalhar com a mesma estrutura de dados JSON para manipulação e intercâmbio simplifica o processo de desenvolvimento ao fornecer acesso declarativo ao objeto na linguagem de programação host do aplicativo.

O foco do XML é fornecer uma notação de intercâmbio autodefinida associada opcionalmente a um esquema rigoroso que pode ser trocado por conta própria. O XML também fornece uma variedade de recursos, tais como espaço de nomes, compactação, assinaturas digitais e segurança, em conjunto com linguagens declarativas, como XQuery e XSLT, que podem ser acionadas a partir das linguagens de programação C, Java™ e Ruby para manipular um ou mais documentos XML.

O JSON não possui a mesma variedade de recursos que o XML.

Representando JSON em XML

O foco deste artigo é mostrar como gerar um formato XML que seja isomórfico (estruturalmente idêntico) em relação a qualquer documento JSON, em outras palavras, como criar um mapeamento universal entre quaisquer documentos JSON e XML.

Para conseguir um mapeamento efetivo entre quaisquer documentos JSON e XML devem ser consideradas as diferenças entre ambos os formatos. Esta seção explora um mapeamento bastante intuitivo, mas não isomórfico, entre XML e JSON, permitindo que estas diferenças sejam compreendidas. A Tabela 1 descreve um exemplo não exaustivo deste mapeamento.

Tabela 1. Mapeamento possível para XML amigável
PadrãoJSONXML Descrição
1{"foo" : "bar"} <foo> bar </foo>Objeto com tipo de valor de cadeia de caractere
2{"foo" : true} <foo> <true/> </foo>Objeto com tipo de valor verdadeiro
3{"foo" : { "true" : null }} <foo> <true/> </foo>Objeto com um objeto aninhado com tipo de valor nulo
4{"foo bar!" : true} Error: "foo bar!" is not a valid QNameO objeto com tipo de valor falso não conseguiu converter porque a chave contém caracteres ilegais para o QName XML (por exemplo, espaço e ponto de exclamação)
5{"foo" : null} <foo/>Objeto com tipo de valor nulo
6{"foo": { "bar" : null}}<foo> <bar/> </foo> Objetos aninhados com o nó folha do tipo nulo
7{"foo": { "bar" : [null, false]}} <foo> <bar> <null/> <false/></bar></foo> Objeto com array aninhada

Nos referimos à notação de mapeamento que usa elemento específico do aplicativo e nomes de atributos, em vez de nomes canônicos do JSONx, como o formato amigável para o JSON. Existem muitas falhas nesse mapeamento. Os Padrões 2 e 3 têm estruturas diferentes e, no entanto, são serializados no mesmo documento XML, tornando impossível a reconstrução do mesmo documento JSON a partir do XML gerado. A chave do objeto do Padrão 4 contém caracteres que não são válidos para um QName de XML. Algumas técnicas podem ser usadas para superar essas limitações, mas elas não apresentam os mesmos pontos fortes de uma notação isomórfica como o JSONx.


JSONx

O JSON XML canônico (JSONx) é apresentado como um formato que é isomórfico ao JSON. Sendo assim, os problemas observados na seção anterior com notações amigáveis não se aplicam ao JSONx.

Na Listagem 2, é possível ver as informações do cliente de Kathy Smith, representada anteriormente em JSON na Listagem 1, como JSONx.

Listagem 2. Informações do cliente para Kathy Smith em JSON XML canônico (JSONx)
<json:object xmlns:json="http://www.ibm.com/xmlns/prod/2009/jsonx">
  <json:object name="customerinfo">
	<json:number name="cid">1000</json:number>
	<json:string name="name">Kathy Smith</json:string>
	<json:object name="addr">
	  <json:string name="country">Canada</json:string>
	  <json:string name="street">5 Rosewood</json:string>
	  <json:string name="city">Toronto</json:string>
	  <json:string name="prov-state">Ontario</json:string>
	  <json:string name="pcode-zip">M6W 1E6</json:string>
	</json:object>
	<json:object name="phone">
	  <json:string name="work">416-555-1358</json:string>
	</json:object>
  </json:object>
</json:object>

O JSONx é um formato apropriado para sistemas que trabalham com dados XML, mas precisam ser estendidos com suporte para JSON. No entanto, ele não representa uma solução genérica para conversão de JSON para XML. No exemplo anterior, é possível especificar as informações originais para Kathy Smith em um formato amigável da seguinte forma:

Listagem 3. Informações do cliente para Kathy Smith em um possível formato XML amigável
<customerinfo>
  <cid>1000</cid>
  <name>Kathy Smith</name>
  <addr>
	<country>Canada</country>
	<street>5 Rosewood</street>
	<city>Toronto</city>
	<prov-state>Ontario</prov-state>
	<pcode-zip>M6W 1E6</pcode-zip>
  </addr>
  <phone>
	<work>416-555-1358</work>
  </phone>
</customerinfo>

Usar JSONx em vez do formato amigável promove os recursos de reutilização de código, conjunto de ferramentas comum, transformação e filtro, que são normalmente associados ao uso de um padrão. É possível ainda optar pela criação de uma visualização que exponha o documento em outro formato mais amigável usando tecnologias XML, tais como XLST e XQuery.

O JSONx permite o uso de infraestrutura XML sem a necessidade de personalizar a solução para processar e armazenar JSON.


Pacote Configurável JSONx

Esta seção fornece uma rápida visão geral do pacote configurável JSONx (uma coleção de scripts e código) para DB2 pureXML que mostra como:

  • Transformar JSON em JSONx
  • Transformar JSONx em JSON
  • Importar documentos JSON como JSONx
  • Armazenar JSONx
  • Indexar JSONx para ganhos de desempenho
  • Expor JSONx em formato relacional
  • Converter JSONx para uma notação XML amigável
  • Juntar documentos JSONx (opcionalmente com predicados relacionais) usando XMLQuery

Para explicações mais detalhadas sobre o que o pacote configurável JSONx possui, consulte o arquivo leia-me que está incluso no pacote.

Pré-requisitos

Para instalar e executar o pacote configurável JSONx, é necessário ter instalado o DB2 v9.5 ou superior. É possível fazer o download do DB2 Express-C, a edição gratuita do DB2 que inclui pureXML, tornando-o totalmente funcional, servidor de dados relacional e XML (consulte a seção Recursos para acesso ao link do site de downloads).

Apesar da possibilidade de executar este pacote em outros sistemas operacionais, ele foi testado com Ubuntu Jaunty Jackalope 9.04 e Microsoft® Windows® XP SP2.

Estrutura da tabela

Na seção anterior foram apresentadas as informações de cliente de Kathy Smith, tanto em JSON quanto em JSONx. Na Tabela 2, é possível ver a tabela do cliente na qual as informações estão armazenadas:

Tabela 2: Tabela JSONXMLADMIN.CUSTOMER
Nome da coluna Tipo de dados Descrição
CID INTEGER ID do Cliente
INFOXML Um registro contendo informações pessoais sobre o cliente
COMMENTVARCHAR(256)Um pequeno identificador textual relativo ao cliente

Há duas outras tabelas existentes no pacote configurável JSONx: Product e PurchaseOrder.

A tabela product contém informações de produto em uma coluna XML chamada DESCRIPTION, bem como um identificador único para aquele produto:

Tabela 3: Tabela JSONXMLADMIN.PRODUCT
Nome da coluna Tipo de dados Descrição
PID INTEGER ID do Produto
DESCRIPTION XML Um registro contendo informações pessoais sobre o produto

A tabela PurchaseOrder descreve a transação na qual o cliente compra um ou mais produtos. Um detalhe interessante sobre essa tabela é que o identificador do cliente não está contido no arquivo JSON original, mas em uma coluna relacional separada. Ao usar o JSONx e o DB2 pureXML, é possível juntar os dados de dois (ou mais) documentos JSON distintos, além de juntar registros relacionais com documentos JSON. Para um exemplo específico de como fazer esta junção, consulte o código processual contido no pacote JSONx.

Tabela 4: Tabela JSONXMLADMIN.PURCHASEORDER
Nome da coluna Tipo de dados Descrição
POID INTEGER ID da ordem de compra
CUSTID INTEGER O ID do cliente associado
PORDER XML Um registro contendo informações sobre a ordem de compra

Transformando JSON em JSONx com funções Java definidas pelo usuário

O pacote configurável JSONx registra duas funções Java definidas pelo usuário (UDFs) em DB2 que permitem converter JSON em JSONx e vice-versa. A Listagem 4 ilustra uma chamada muito simples da função definida pelo usuário que transforma JSON em JSONx.

Listagem 4. Chamando a função Java JSONTOXML definida pelo usuário
 SELECT JSONXML.JSONTOXML('{"foo": "bar"}') FROM SYSIBM.SYSDUMMY1

A Listagem 5 mostra o resultado da instrução de SELECT na Listagem 4.

Listagem 5. Resultado produzido pela chamada na Listagem 4
<json:object xmlns:json="http://www.ibm.com/xmlns/prod/2009/jsonx">
 <json:string name="foo"> bar </json:string>
</json:object>

Para transformar JSONx em JSON, chame o procedimento armazenado XMLTOJSON. A Listagem 6 mostra um exemplo onde o mesmo documento JSON que foi usado na Listagem 4 é serializado no JSONx e retornado para JSON.

Listagem 6. JSON para JSONx e retornar para JSON
SELECT JSONXML.XMLTOJSON(JSONXML.JSONTOXML('{"foo": "bar"}')) FROM SYSIBM.SYSDUMMY1

Juntando documentos JSONx

Um dos excelentes recursos existentes em DB2 pureXML é a variedade de opções para junção de dados. Armazenar o JSONx no DB2 pureXML significa que agora é possível juntar os dados JSON da mesma forma como era feito com documentos XML. A Listagem 7 mostra como usar uma junção com predicados relacionais e XML e retornar, para cada Ordem de Compra, o POID e o nome do cliente.

Listagem 7. Juntando JSONx com predicados relacionais e XML
SELECT
  POID, 
  XMLCAST (
	XMLQUERY(
	  ''declare default element namespace "http://www.ibm.com/xmlns/prod/2009/jsonx";
	  data( 
		$INFO/object/object[@name="customerinfo"]/string[@name="name"]/text() )''
	  ) AS VARCHAR(32) 
	) AS CUSTNAME
FROM
  JSONXMLADMIN.PURCHASEORDER , 
  JSONXMLADMIN.CUSTOMER
WHERE
  XMLEXISTS(
	''declare default element namespace "http://www.ibm.com/xmlns/prod/2009/jsonx";
	$INFO/object/object[@name="customerinfo"]/number[@name="cid"][. = $CUSTID]'' 
  )

DB2 9.7

O pacote configurável JSONx também ilustra algumas das mais novas adições ao DB2 pureXML v9.7. Ao criar uma visualização em um documento JSONx com XMLTABLE, o DB2 v9.7 obtém os índices XML aplicáveis, fazendo com que a consulta seja muito mais rápida do que nas versões anteriores.

Listagem 8. Expondo JSON como visualização relacional com XMLTable
CREATE VIEW JSONXMLADMIN.RELCUSTOMER(CID, NAME, PHONE) AS 
 SELECT  *
 FROM
  XMLTABLE(
   XMLNAMESPACES (DEFAULT 'http://www.ibm.com/xmlns/prod/2009/jsonx'),
   'db2-fn:xmlcolumn("JSONXMLADMIN.CUSTOMER.INFO")'
    COLUMNS
	  "CID" INTEGER 
	  PATH '/object/object[@name="customerinfo"]/number[@name="cid"]/xs:double(.)' ,
	  "NAME" VARCHAR(32) 
	  PATH '/object/object[@name="customerinfo"]/string[@name="name"]/text()' ,
	  "PHONE" VARCHAR(32)
	  PATH '/object/object[@name="customerinfo"]/object[@name="phone"][1]/*[1]/text()'
	)

Também é possível produzir JSONx de dados relacionais usando as funções de publicação em SQL/XML.

Outro novo recurso é o suporte do tipo de dados em XML em funções definidas pelo usuário, permitindo a manipulação de documentos XML. Ao usar o DB2 v9.7 para executar o pacote configurável JSONx, são usados outros dois novos recursos para produzir o resultado: indexando na visualização e uma função em XML definida pelo usuário.

A UDF inclusa no pacote configurável JSONx usa o Recurso de atualização do XQuery para transformar JSONx em um formato que seja adequado para representar o subconjunto específico do JSON que será importado assim que a execução do banco de dados de amostra JSONx estiver finalizada. Apesar de não representar um algoritmo de transformação genérico ou eficiente, a Listagem 9 mostra como é possível programar efetivamente funções XML avançadas definidas pelo usuário usando DB2 pureXML:

Listagem 9. Exemplo de UDF em XML usada para gerar XML amigável
CREATE FUNCTION JSONXMLADMIN.JSONXTOFRIENDLY(JSONX XML)
RETURNS XML
BEGIN ATOMIC
  RETURN XMLQUERY('
	declare namespace json="http://www.ibm.com/xmlns/prod/2009/jsonx";
	copy $n := $JSONX
	modify(
	  for $e in $n//json:*
	  where $e/@name
	  return (
		do rename $e as replace($e/@name," ", "_") ,
		do delete $e/@name
	  )
	)
	return document { $n/json:object/* }
  ');
END

A Listagem 10 mostra como transformar uma informação de cliente que foi colocada na notação amigável anterior de volta para JSONx.

Listagem 10. Transformando as informações amigáveis da cliente Kathy Smith de volta para JSONx
SELECT
  XMLQUERY('
	declare namespace json="http://www.ibm.com/xmlns/prod/2009/jsonx";
	copy $n := $friendly
	modify(
	  for $e in $n//*
	  let $name := local-name($e)
	  let $type := 
		if ($name = ("addr", "phone", "customerinfo")) then "json:object"
		else if ($name eq "cid") then "json:number"
		else "json:string"
	  return (
		do rename $e as $type,
		do insert attribute name { $name } into $e
	  )
	)
	return document { 
	  <json:object>
		{ $n } 
	  </json:object>
	}
  ' PASSING JSONXMLADMIN.JSONXTOFRIENDLY(INFO) as "friendly")
  FROM
	JSONXMLADMIN.CUSTOMER
  WHERE
	CID = 1000

Executando o pacote configurável JSONx

Siga as etapas listadas abaixo para configurar o pacote JSONx:

  • Para uso em plataformas Windows, simplesmente extraia o arquivo jsonx.zip que está disponível na seção de recursos no seu sistema de arquivos. Em plataformas Linux®, descompacte o arquivo jsonx.zip usando unzip -a -aa jsonx.zip. Isso garante que os caracteres de terminação da linha corretos sejam usados.
  • Nos sistemas Windows, certifique-se de que o ambiente do processador da linha de comando DB2 seja inicializado. Em sistemas baseados em Linux, verifique se está conectado com um usuário que tenha acesso ao DB2 (db2inst1 é o usuário padrão do DB2).
  • Tudo pronto para executar os scripts. (OBSERVAÇÃO: Esteja ciente de que os scripts de início podem configurar alguns dos parâmetros do DBMS e podem PARAR e REINICIAR o DBMS para garantir que o mesmo possa lidar com o procedimento armazenado em jar. Se estiver preocupado com os scripts, revise-os antes de executá-los!) Execute start.bat nas plataformas Windows. Em plataformas Linux, use start.sh. Ao finalizar este script, é possível ver algo parecido com a Figura 3 no prompt de comandos ou bash. (Consulte uma versão de texto do resultado da amostra na Figura 3.)
Figura 3. Exemplo de resultado do pacote configurável JSONx
Exemplo de resultado do pacote configurável JSONx

Neste ponto, tudo está configurado e é possível ver os resultados da consulta na pasta de saída. Para verificar se os resultados criados estão corretos, pode-se comparar os arquivos de saída na pasta de saída com o resultado de referência que está localizado na pasta de referência.

Se os exemplos não corresponderem à pasta de referência, consulte o arquivo de log localizado no diretório de logs para encontrar o que pode ter causado a falha na execução.

Para uma ilustração de tweets do Twitter em XML amigável e em JSONx, consulte o Anexo A.


Conclusão

Neste artigo, um novo formato (JSONx) foi apresentado, permitindo o armazenamento de JSON como XML no DB2 pureXML. As diferenças entre JSONx e outros formatos amigáveis foram destacadas. Um caso de uso típico para o JSON foi discutido e destacou-se os benefícios de usar pureXML para armazenar JSON. Finalmente, com o download do JSONx (pacote configurável JSONx) pode-se ter uma base para criar aplicativos JSON habilitados para XML.

Os próximos dois artigos desta série focarão na exposição do banco de dados de amostra em JSONx (criado no pacote configurável JSONx) através do JSON Universal Services, e então focam na criação da camada de apresentação com os dispositivos Open-social que se apoiam no JSON Universal Services como backend.

Uma possibilidade futura é a de considerar maneiras pelas quais os desenvolvedores da Web acessam documentos JSON (armazenados como JSONx) com o JSONPath.


Reconhecimento

Gostaríamos de agradecer a Brien Muschett e William Palma pelas suas contribuições.


Anexo A

Como mencionado em Um típico cenário JSON, muitos serviços da Web fornecem múltiplos formatos de exibição de informações. Os padrões de mercado como Atom e RSS, JSON ou até mesmo as notações amigáveis XML são exemplos desses formatos. O Twitter oferece uma API para acessar tweets por ID. Nesse anexo, mostramos os resultados do envio de dois pedidos ao Twitter usando curl, um em JSON e outro em XML amigável. Em seguida demonstramos como converter o XML amigável em JSONx.

Na Listagem 11, usamos curl para chamar a informação sobre uma mensagem individualizada (o tweet cujo id é 2311383114) que foi enviada ao twitter.com. Para recuperar a informação do tweet (seu status), é possível chamar curl do seu terminal como na Listagem 11 e o status daquele tweet é retornado em formato JSON. (Observação: A chamada de curl nas Listagens 11 e 12 está dividida em duas linhas para o propósito de formatação.)

Listagem 11. Recuperar o status com o ID 2311383114 no formato JSON
purexml@watson.ibm.com:~$ curl 
http://purexmltest:3ce3ac99@twitter.com/statuses/show.xml?id=2311383114

{
    "text": "Hello World!",
    "in_reply_to_user_id": null,
    "user": {
        "following": null,
        "favourites_count": 0,
        "profile_sidebar_fill_color": "e0ff92",
        "description": null,
        "verified": false,
        "utc_offset": null,
        "statuses_count": 1,
        "profile_sidebar_border_color": "87bc44",
        "followers_count": 0,
        "created_at": "Wed Jun 24 14:18:32 +0000 2009",
        "url": null,
        "name": "pureXML TEST",
        "friends_count": 0,
        "profile_text_color": "000000",
        "protected": false,
        "profile_image_url": "http:\/\/s3.amazonaws.com\/twitter_production
		\/profile_images\/280225879\/twitterxml-1_bigger_normal.png",
        "profile_background_image_url": "http:\/\/static.twitter.com
		\/images\/themes\/theme1\/bg.gif",
        "notifications": null,
        "time_zone": null,
        "profile_link_color": "0000ff",
        "screen_name": "purexmltest",
        "profile_background_tile": false,
        "profile_background_color": "9ae4e8",
        "location": null,
        "id": 50316451
    },
    "favorited": false,
    "created_at": "Wed Jun 24 15:04:13 +0000 2009",
    "in_reply_to_screen_name": null,
    "truncated": false,
    "id": 2311383114,
    "in_reply_to_status_id": null,
    "source": "web"
}

Alternativamente, é possível recuperar o mesmo documento em Atom, RSS ou em notação XML amigável. Na Listagem 12, a mesma função é chamada para recuperar o status, mas desta vez em notação XML amigável:

Listagem 12. Recuperar o status com o ID 2311383114 no formato XML amigável
purexml@watson.ibm.com:~$ curl 
http://purexmltest:3ce3ac99@twitter.com/statuses/show.xml?id=2311383114

<?xml version="1.0" encoding="UTF-8"?>
<status>
  <created_at>Wed Jun 24 15:04:13 +0000 2009</created_at>
  <id>2311383114</id>
  <text>Hello World!</text>
  <source>web</source>
  <truncated>false</truncated>
  <in_reply_to_status_id></in_reply_to_status_id>
  <in_reply_to_user_id></in_reply_to_user_id>
  <favorited>false</favorited>
  <in_reply_to_screen_name></in_reply_to_screen_name>
  <user>
    <id>50316451</id>
    <name>pureXML TEST</name>
    <screen_name>purexmltest</screen_name>
    <location></location>
    <description></description>
    <profile_image_url>http://s3.amazonaws.com/twitter_production/
	profile_images/280225879/twitterxml-1_bigger_normal.png</profile_image_url>
    <url></url>
    <protected>false</protected>
    <followers_count>0</followers_count>
    <profile_background_color>9ae4e8</profile_background_color>
    <profile_text_color>000000</profile_text_color>
    <profile_link_color>0000ff</profile_link_color>
    <profile_sidebar_fill_color>e0ff92</profile_sidebar_fill_color>
    <profile_sidebar_border_color>87bc44</profile_sidebar_border_color>
    <friends_count>0</friends_count>
    <created_at>Wed Jun 24 14:18:32 +0000 2009</created_at>
    <favourites_count>0</favourites_count>
    <utc_offset></utc_offset>
    <time_zone></time_zone>
    <profile_background_image_url>
http://static.twitter.com/images/themes/theme1/bg.gif</profile_background_image_url>
    <profile_background_tile>false</profile_background_tile>
    <statuses_count>1</statuses_count>
    <notifications></notifications>
    <verified>false</verified>
    <following></following>
  </user>
</status>

A Listagem 13 mostra um exemplo de chamada da UDF em DB2 que converte JSON em JSONx sobre os resultados obtidos na Listagem 12.

Listagem 13. Representação JSONx do documento JSON que foi obtido na Listagem 12.
db2 => SELECT JSONXML.JSONTOXML('{"text":"Hello World!",
"in_reply_to_user_id":null,"user":{"following":null,
"favourites_count":0,"profile_sidebar_fill_color":"e0ff92",
"description":null,"verified":false,"utc_offset":null,
"statuses_count":1,"profile_sidebar_border_color":"87bc44",
"followers_count":0,"created_at":"Wed Jun 24 14:18:32 +0000 2009",
"url":null,"name":"pureXML TEST","friends_count":0,
"profile_text_color":"000000","protected":false,"profile_image_url":
"http:\/\/s3.amazonaws.com\/twitter_production
\/profile_images\/280225879\/twitterxml-1_bigger_normal.png",
"profile_background_image_url":"http:\/\/static.twitter.com
\/images\/themes\/theme1\/bg.gif",
"notifications":null,"time_zone":null,"profile_link_color":"0000ff",
"screen_name":"purexmltest","profile_background_tile":false,
"profile_background_color":"9ae4e8","location":null,"id":50316451},
"favorited":false,"created_at":"Wed Jun 24 15:04:13 +0000 2009",
"in_reply_to_screen_name":null,"truncated":false,"id":2311383114,
"in_reply_to_status_id":null,"source":"web"}') FROM SYSIBM.SYSDUMMY1

<json:object xmlns:json="http://www.ibm.com/xmlns/prod/2009/jsonx">
  <json:string name="text">Hello World!</json:string>
  <json:null name="in_reply_to_user_id"/>
  <json:object name="user">
    <json:null name="following"/>
    <json:number name="favourites_count">0</json:number>
    <json:string name="profile_sidebar_fill_color">e0ff92</json:string>
    <json:null name="description"/>
    <json:boolean name="verified">false</json:boolean>
    <json:null name="utc_offset"/>
    <json:number name="statuses_count">1</json:number>
    <json:string name="profile_sidebar_border_color">87bc44</json:string>
    <json:number name="followers_count">0</json:number>
    <json:string name="created_at">Wed Jun 24 14:18:32 +0000 2009</json:string>
    <json:null name="url"/>
    <json:string name="name">pureXML TEST</json:string>
    <json:number name="friends_count">0</json:number>
    <json:string name="profile_text_color">000000</json:string>
    <json:boolean name="protected">false</json:boolean>
    <json:string name="profile_image_url"
	>http://s3.amazonaws.com/twitter_production/profile_images
	/280225879/twitterxml-1_bigger_normal.png</json:string>
    <json:string name="profile_background_image_url"
	>http://static.twitter.com/images/themes/theme1/bg.gif</json:string>
    <json:null name="notifications"/>
    <json:null name="time_zone"/>
    <json:string name="profile_link_color">0000ff</json:string>
    <json:string name="screen_name">purexmltest</json:string>
    <json:boolean name="profile_background_tile">false</json:boolean>
    <json:string name="profile_background_color">9ae4e8</json:string>
    <json:null name="location"/>
    <json:number name="id">50316451</json:number>
  </json:object>
  <json:boolean name="favorited">false</json:boolean>
  <json:string name="created_at">Wed Jun 24 15:04:13 +0000 2009</json:string>
  <json:null name="in_reply_to_screen_name"/>
  <json:boolean name="truncated">false</json:boolean>
  <json:number name="id">2311383114</json:number>
  <json:null name="in_reply_to_status_id"/>
  <json:string name="source">web</json:string>
</json:object>

Download

DescriçãoNomeTamanho
JSONx Bundlejsonx.zip145KB

Recursos

Aprender

Obter produtos e tecnologias

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=450116
ArticleTitle=Criação de um aplicativo JSON e pureXML, Parte 1: Armazenar e consultar o JSON com o DB2 pureXML
publish-date=11272009