Creación de una aplicación pureXML y JSON: Parte 1: Almacenamiento y consulta de JSON con DB2 pureXML

Adopción de un mapeo simple JSON a XML

JavaScript Object Notation (JSON), una notación textual popular en Web 2.0, se usa para representar objetos (o estructuras de datos) como texto serializado cuando los clientes y los servidores intercambian información. Algunas aplicaciones se benefician de objetos JSON persistentes para conservar el estado en las diferentes sesiones. En este artículo, usted aprenderá como DB2® pureXML® puede almacenar, gestionar y consultar JSON cuando usted adopta un mapeo simple JSON a XML.

Nuno Job, CoOp: DB2 Technical Enablement Specialist, IBM  

Photo of Nuno JobNuno Job es estudiantes de posgrado de la Universidad de Minho y realizó una pasantía en IBM en el T.J. Watson Research Center como parte del equipo de activación de pureXML. Entre sus intereses están las tecnologías de código abierto, Linux, la seguridad, la privacidad y las bases de datos jerárquicas. En la actualidad, Nuno está trabajando para IBM en Toronto, donde se desempeña como DB2 Technical Enablement Specialist ayudando a los clientes a obtener validación en los programas de socios de IBM y a actualizar una aplicación IBM Ruby on Rails.



Susan Malaika, Senior Technical Staff Member, IBM

Photo of Susan MalaikaSusan Malaika es Senior Technical Staff Member para el IBM Information Management Group (parte del IBM Software Group). Entre sus especialidades se incluyen XML, la Web y las bases de datos. Susan ha desarrollado estándares que respaldan datos para entornos distribuidos en el Global Grid Forum. Además de trabajar como desarrolladora de software para los productos de IBM, también se desempeñó como especialista en Internet, analista de datos y diseñadora y desarrolladora de aplicaciones. También es coautora de un libro que se encuentra en la Web y ha publicado varios artículos sobre el procesamiento de transacciones y XML. Susan es miembro de la IBM Academy of Technology.



Michael Schenker, Advisory Software Engineer, IBM

Author Photo: Michael SchenkerMichael Schenker obtuvo su segundo título universitario en ciencias de la computación en la Universidad de Ciencias Aplicadas de Leipzig, Alemania. Tiene 7 años de experiencia profesional con IBM. A lo largo de su carrera, trabajó en varios productos relacionados con las bases de datos. Comenzó como pasante trabajando para DB2 Information Integration, con especialización en contenedores no relacionales. Luego, a fines de 2003, comenzó a trabajar para IBM como empleado de tiempo completo. En 2006 se unió a la organización de herramientas para bases de datos y trabajó en la funcionalidad de proveedores de servicios web de DB2 en IBM Data Studio Developer. Gracias a esto, adquirió gran experiencia en tecnologías Web y SOA. Recientemente, Michael ingresó al equipo optimizador de DB2 for z/OS, aunque sigue estando interesado en las tecnologías Web y SOA relacionadas con DB2.



29-07-2011 (Primera publicación 05-03-2010)

Introducción

JavaScript (que se define en ECMAScript Language Specification en ECMA) es un lenguaje de scripting que se implementó por primera vez en Netscape Navigator (un navegador Web) para mejorar el procesamiento de páginas Web. JSON (que se define en RFC 4627 en IETF) es un formato que representa estructuras de datos JavaScript (como, por ejemplo, objetos y arrays) como texto serializado.

Términos frecuentes

  • Ajax: JavaScript Asíncrono + XML
  • API: Interfaz de Programación de Aplicaciones
  • DBMS: Sistema de Gestión de Bases de Datos
  • DOM: Modelo de Objeto del Documento
  • HTTP: Protocolo de Transferencia de Hipertexto
  • IETF: Grupo de Trabajo en Ingeniería de Internet
  • RFC: Solicitud de Comentarios
  • RSS: Sindicación Realmente Simple
  • SAX: API Simple para XML
  • SOA: Arquitectura Orientada a Servicios
  • W3C: Consorcio World Wide Web
  • XHTML: Lenguaje de Marcado de Hipertexto Extensible
  • XML: Lenguaje de Marcado Extensible
  • XSLT: Transformaciones de Lenguaje de Hoja de Estilo Extensible

Mientras que XML (que se define en la especificación XML 1.0 en W3C) es una representación común para el intercambio de mensajes entre servidores y clientes de acoplamiento holgado, JSON se suele usar para esto mismo. Una de las razones que justifica la adopción de JSON es que los objetos JSON son fáciles de manipular usando lenguajes de scripting (como, por ejemplo, JavaScript, Python o Ruby).

La idea de almacenar y consultar XML en bases de datos surgió luego de que el uso de XML para el intercambio de datos pasó a ser algo predominante. De manera similar, y a diferencia del almacenamiento, la manipulación y el intercambio de JSON se ha transformado en algo muy común. Sin embargo, han comenzado a aparecer sistemas de gestión de bases de datos orientados a documentos JSON. Por ejemplo, Apache CouchDB está muy alineado con JSON por medio de sus interfaces y su almacenamiento.

En este artículo, introducimos la noción del intercambio de JSON como XML para sacar provecho de los procesadores XML, los dispositivos XML, el almacenamiento XML (generalmente presente en las bases de datos XML como DB2 pureXML) y otras tecnologías XML (como, por ejemplo, XQuery y XSLT). Para lograr esto, introduciremos un formato XML denominado JSONx, describiremos una notación JSON a XML amigable y explicaremos las diferencias que existen entre JSONx y los formatos amigables.

Siguiendo los pasos que se mencionan en este artículo y en el archivo para descargar que lo acompaña, usted puede crear una tienda JSON con índice y capacidades de búsqueda basada en la base de datos de muestra de DB2 pureXML. Éste es el primero de una serie de tres artículos que ilustran cómo crear una aplicación pureXML de tres niveles, basada en JSON y que incorpore dispositivos de OpenSocial, JSON y servicios web.

Figura 1. Generalidades de la arquitectura Universal Services
Generalidades de la arquitectura Universal Services

Universal Services son un conjunto simple pero fijo de operaciones de base de datos que permiten la búsqueda y la modificación de datos XML, almacenados en una columna pureXML de una base de datos DB2. Estas operaciones de base de datos le permiten insertar, actualizar, borrar y consultar los datos expuestos como servicios web por medio del mecanismo Data Web Service. Ver la sección denominadan Recursos(Recursos) para obtener mayor información sobre Universal Services para pureXML. Los JSON Universal Services para pureXML exponen las mismas operaciones de base de datos ante los clientes, pero en JSON en vez de en XML, mientras que continúan trabajando con XML en el servidor. La aplicación cliente desconoce que los JSON entrantes y salientes se están transformando en XML en el servidor en la base de datos.

Este artículo también explora las opciones que usted tiene para representar JSON como XML y, luego de esto, se encarga de describir algunos escenarios y cómo se puede aplicar IBM DB2 pureXML en dichos escenarios. Este artículo está acompañado por un archivo para descargar (al que se denomina paquete JSONx) que usted puede usar para crear una base de datos JSONx pureXML de muestra. Dicho archivo también puede servir de base para todas las aplicaciones JSONx. El archivo para descargar también incluye dos funciones DB2 definidas por el usuario que realizan la conversión de JSON a JSONx y viceversa.

JSON

JSON es un formato basado en texto y que cualquier persona puede leer que se usa para intercambiar datos entre clientes y servidores. Además, le ofrece a los desarrolladores un formato de intercambio que realiza el mapeo directamente hacia las estructuras de datos que usan. Para esto, JSON define las siguientes estructuras de datos principales: número, cadena, booleano (verdadero y falso), array (una secuencia ordenada de valores), objeto (una colección de pares de valores clave) y nulo.

El Listado 1 ilustra un objeto JSON que describe un cliente. Hay dos objetos anidados dentro del objeto customerinfo que definen la ID del cliente (cid) y su nombre. El objeto customerinfo también incluye dos objetos estructurados para definir el domicilio y los números de teléfono del cliente.

Listado 1. Información correspondiente a la clienta Kathy Smith en 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" } } }

Un escenario JSON típico

Un caso de uso típico para JSON consiste en contar con una aplicación Web que intercambia datos con una API (como, por ejemplo, Yahoo Web Services o la API de Twitter). En este escenario, una aplicación Web usa solicitudes JavaScript asíncronas (Ajax) para comunicar a JSON con el servicio web que expone la API.

Frecuentemente, dicha API permite que la aplicación elija el formato de intercambio. Entre los formatos comunes soportados, podemos mencionar los siguientes: XML, estándares XML predefinidos (como, por ejemplo, RSS y Atom) y JSON. Para obtener ejemplos de dichos formatos, ver la sección denominada Anexo A.

La libertad para elegir el formato que se usa para realizar la comunicación entre la aplicación y el servicio web hace que los desarrolladores puedan acelerar el proceso de desarrollo. Sin embargo, esto genera preguntas en relación con la actualización de una infraestructura que soporta formatos múltiples de manera concurrente. La lista que figura a continuación incluye algunas de las opciones para el almacenamiento de datos:

  • Use una base de datos JSON centrada en el documento (como, por ejemplo, Apache CouchDB).
  • Use una base de datos relacional que desmenuce y reconstruya JSON para cada solicitud.
  • Use el almacenamiento nativo XML (que almacene JSONx) y ofrezca interfaces que expongan y procesen JSON.

La Figura 2 ilustra ejemplos de cada una de estas opciones de almacenamiento de datos. (Ver una versión ampliada de la Figura 2.)

Figura 2. Diferentes formas de almacenar JSON
Diferentes formas de almacenar JSON

Todos estos enfoques tienen sus puntos a favor y en contra. Este artículo no analiza esas diferencias, sino que se concentra en un escenario en el que el uso de pureXML es el enfoque más conveniente para una aplicación específica. A continuación, mencionamos algunas de las razones que pueden hacer que XML sea el enfoque más conveniente:

  • El resto de la infraestructura ya usa XML y SOA
  • La existencia de dispositivos XML (como, por ejemplo, IBM Websphere® DataPower®) y tecnologías XML que se pueden extender para que trabajen con JSONx

Diferencias entre JSON y XML

Cuando los desarrolladores usan XML para el intercambio, suelen navegar el XML por medio de XML DOM o SAX. La capacidad de trabajar con la misma estructura de datos JSON a los fines de la manipulación y el intercambio simplifica el proceso de desarrollo mediante la provisión de acceso declarativo al objeto en el lenguaje de programación host de la aplicación.

XML se concentra en ofrecer una notación de intercambio que se autodefina y que, opcionalmente, esté asociada a un esquema riguroso que se pueda intercambiar. XML también le ofrece una variedad de características (como, por ejemplo, espacios de nombres, compresión, firmas digitales y seguridad) junto con lenguajes declarativos, como XQuery y XSLT, que se pueden invocar desde los lenguajes de programación C, Java™ y Ruby para manipular uno o más documentos XML.

JSON no cuenta con la variedad de características que tiene XML.

Representación de JSON en XML

Este artículo se concentra en mostrarle cómo generar un formato XML que sea isomorfo (estructuralmente idéntico) a cualquier documento JSON (es decir que le indica cómo crear un mapeo universal entre cualquier documento JSON y cualquier documento XML).

Para lograr un mapeo efectivo entre cualquier documento JSON y XML, usted debe considerar las diferencias que existen entre ambos formatos. Esta sección explora un mapeo bastante intuitivo, aunque no isomorfo, entre XML y JSON para que usted pueda comprender dichas diferencias. La Tabla 1 describe un ejemplo no exhaustivo de dicho mapeo.

Tabla 1. Mapeo posible para un XML amigable
PatrónJSONXMLDescripción
1{"foo" : "bar"}<foo> bar </foo>Objeto con tipo de valor cadena
2{"foo" : true}<foo> <true/> </foo>Objeto con tipo de valor verdadero
3{"foo" : { "true" : null }}<foo> <true/> </foo>Objeto con un Objeto anidado con tipo de valor nulo
4{"foo bar!" : true}Error: "foo bar!" is not a valid QNameEl objeto con tipo de valor falso no se convierte adecuadamente porque la clave incluye caracteres ilegales para un XML QName (por ejemplo, espacios y signos de exclamación)
5{"foo" : null}<foo/>Objeto con tipo de valor nulo
6{"foo": { "bar" : null}}<foo> <bar/> </foo>Objetos anidados con nodo hoja de tipo nulo
7{"foo": { "bar" : [null, false]}}<foo> <bar> <null/> <false/></bar></foo>Objeto con array anidado

Hacemos referencia a una notación de mapeo que usa nombres de atributo y elemento específicos a la aplicación, en vez de nombres JSONx canónicos (como, por ejemplo, el formato amigable para JSON). Existen muchos defectos en este mapeo. Los Patrones 2 y 3 tienen estructuras diferentes y, sin embargo, están serializados en el mismo documento XML, lo que hace que sea imposible reconstruir el mismo documento JSON a partir del XML generado. La clave de objeto del Patrón 4 incluye caracteres que no son válidos para un XML QName. Se pueden usar algunas técnicas para superar estas limitaciones, pero ellas no tendrán las mismas ventajas que una notación isomorfa (como, por ejemplo, JSONx).


JSONx

El JSON XML canónico (JSONx) se introduce como un formato que es isomorfo a JSON. Por lo tanto, los problemas que mencionamos en la sección anterior con las notaciones amigables no forman parte de JSONx.

En elListado 2, usted puede observar la información de la clienta Kathy Smith, que anteriormente figuraba en JSON en el Listado 1, como JSONx.

Listado 2. Información de la clienta Kathy Smith en 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>
                lt;/json:object>

JSONx es un formato adecuado para aquellos sistemas que operan con datos XML pero necesitan que se los extienda para que soporten JSON. Sin embargo, esto no representa una solución infalible para convertir JSON en XML. En el ejemplo anterior, uno podía especificar la información original correspondiente a Kathy Smith en un formato amigable de la siguiente manera:

Listado 3. Información de la clienta Kathy Smith en un formato XML amigable posible
<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>

Al usar JSONx en vez del formato amigable, se promueve la reutilización del código, las herramientas comunes y las capacidades de filtrado y transformación que se suelen asociar con el uso de un estándar. Usted todavía puede optar por crear una vista que exponga el documento en otro formato más amigable usando tecnologías XML (como, por ejemplo, XSLT y XQuery).

JSONx le permite usar la infraestructura XML existente sin que exista la necesidad de personalizar la solución para procesar y almacenar JSON.


Paquete JSONx

Esta sección le ofrece una breve reseña de un paquete JSONx (una colección de scripts y códigos) para DB2 pureXML que le muestra cómo:

  • Transformar JSON en JSONx
  • Transformar JSONx en JSON
  • Importar documentos JSON como JSONx
  • Almacenar JSONx
  • Indexar JSONx para un mejor rendimiento
  • Exponer JSONx en un formato relacional
  • Convertir JSONx en una notación XML amigable
  • Unir documentos JSONx (opcionalmente, con predicados relacionales) usando XMLQuery

Para obtener una explicación más detallada de todo lo que forma parte del paquete JSONx, vea el archivo readme incluido en el paquete.

Requisitos previos

Para instalar y ejecutar el paquete JSONx, es necesario tener instalado DB2 v9.5 (o una versión posterior). Puede descargar DB2 Express-C, la edición abierta de DB2 que incluye pureXML, lo que la transforma en un servidor de datos XML y relacional completamente funcional. Ver la sección denominada Recursos, donde encontrará un vínculo hacia el sitio desde el que puede descargar el archivo.

Aunque es posible que este paquete se pueda ejecutar en otros sistemas operativos, se lo probó en Ubuntu Jaunty Jackalope 9.04 y Microsoft® Windows® XP SP2.

Estructura de la tabla

En la sección anterior, le presentamos la información correspondiente a la clienta Kathy Smith, tanto en JSON como en JSONx. En la Tabla 2, puede observar la Tabla del cliente donde se almacena la información:

Tabla 2: Tabla JSONXMLADMIN.CUSTOMER
Nombre de la columnaTipo de datosDescripción
CIDINTEGERID del cliente
INFOXMLUn registro que incluye información personal sobre el cliente
COMMENTVARCHAR(256)Un pequeño identificador textual relacionado con el cliente

Existen otras dos Tablas en el paquete JSONx denominadas Product (Producto) y PurchaseOrder (Orden de compra).

La Tabla denominada Product incluye información del producto en una columna XML denominada DESCRIPTION (DESCRIPCIÓN), además del identificador exclusivo correspondiente a dicho producto:

Tabla 3: Tabla JSONXMLADMIN.PRODUCT
Nombre de la columnaTipo de datosDescripción
PIDINTEGERID del producto
DESCRIPTIONXMLUn registro que incluye información personal sobre el producto

La Tabla denominada PurchaseOrder describe una transacción en la que un cliente compra uno o más productos. Un detalle interesante de esta Tabla es que el identificador del cliente no se incluye en el archivo JSON original sino que en una columna relacional independiente. Al usar JSONx y DB2 pureXML, usted puede unir los datos de dos (o más) documentos JSON diferentes. Usted también puede unir registros relacionales con los documentos JSON. Para ver un ejemplo específico sobre cómo realizar esta unión, vea el código de procedimientos que se incluye en el paquete JSONx.

Tabla 4: Tabla JSONXMLADMIN.PURCHASEORDER
Nombre de la columnaTipo de datosDescripción
POIDINTEGERID de la orden de compra
CUSTIDINTEGERLa ID del cliente asociado
PORDERXMLUn registro que incluye información sobre la orden de compra

Transformación de JSON en JSONx con funciones Java definidas por el usuario

El paquete JSONx registrará dos funciones Java definidas por el usuario (UDF) en DB2 que le permiten convertir JSON en JSONx y viceversa. El Listado 4ilustra una invocación muy simple de la función definida por el usuario que transforma JSON en JSONx.

Listado 4. Invocación de la función Java definida por el usuario JSONTOXML
SELECT
JSONXML.JSONTOXML('{"foo": "bar"}') FROM SYSIBM.SYSDUMMY1

El Listado 5 le muestra los datos de salida de la instrucción SELECT (SELECCIÓN) en el Listado 4.

Listado 5. Datos de salida producidos por la invocación en el Listado 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 en JSON, invoque el procedimiento almacenado XMLTOJSON. El Listado 6 le muestra un ejemplo en el que el mismo documento JSON que se usó en el Listado 4 se serializa en JSONx y, luego de esto, de vuelta en JSON.

Listado 6. De JSON a JSONx y de vuelta a JSON
SELECT
JSONXML.XMLTOJSON(JSONXML.JSONTOXML('{"foo": "bar"}')) FROM SYSIBM.SYSDUMMY1

Unión de documentos JSONx

Una de las características apasionantes que forman parte de DB2 pureXML es la variedad de opciones disponibles para unir datos. Almacenar JSONx en DB2 pureXML significa que usted puede unir sus datos JSON de la misma forma que lo hizo con los documentos XML. El Listado 7 le muestra cómo usar una unión con predicados y devolución tanto relacionales como XML, para cada Orden de compra, el POID, y el nombre del cliente.

Listado 7. Unión de JSONx con predicados tanto relacionales como 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

El paquete JSONx también ilustra algunas de las nuevas adiciones en DB2 v9.7 pureXML. Cuando se crea una vista en un documento JSONx con XMLTABLE, DB2 v9.7 elegirá los índices XML aplicables y, por lo tanto, hará que la consulta sea mucho más rápida que en las versiones anteriores.

Listado 8. Exposición de JSON como una vista relacional con 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()' )

También es posible producir JSONx a partir de datos relacionales usando las funciones de publicación SQL/XML.

Otra de las nuevas características es el soporte del tipo de datos XML en funciones definidas por los usuarios, lo que le permite manipular documentos XML. Cuando usa DB2 v9.7 para ejecutar el paquete JSONx, usted usa otras dos nuevas características para producir los datos de salida: el indexado en la vista y una función XML definida por el usuario.

La UDF que se incluye en el paquete JSONx usa XQuery Update Facility para transformar JSONx en un formato adecuado para representar el subgrupo específico de JSON que se importará una vez que finalice la ejecución de la base de datos de muestra JSONx. Mientras que esto no representa un algoritmo de transformación genérico o eficiente, el Listado 9 le muestra cómo usted puede programar efectivamente funciones XML avanzadas y definidas por el usuario usando DB2 pureXML:

Listado 9. Muestra de la XML UDF usada para generar XML amigable
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

El Listado 10 le muestra cómo volver a transformar la información del cliente que se colocó en la notación amigable anterior en JSONx.

Listado 10. Transformación de la información amigable de Kathy Smith en 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",
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

Ejecución del paquete JSONx

Siga los pasos que figuran a continuación para configurar el paquete JSONx:

  • Para usarlo en plataformas Windows, simplemente descomprima el archivo jsonx.zip que figura en la sección Recursos de su sistema de archivos. En plataformas Linux®, descomprima el archivo jsonx.zip usando unzip -a -aa jsonx.zip. Esto asegurará que se usen los caracteres correctos de terminación de línea.
  • En los sistemas Windows, asegúrese de inicializar el entorno procesador de líneas de comando DB2. En los sistemas basados en Linux, asegúrese de haber iniciado sesión con un usuario que tenga acceso a DB2 (db2inst1 es el usuario DB2 predeterminado).
  • Ya está listo para ejecutar los scripts. (NOTA: Tenga en cuenta que los scripts de inicio pueden llegar a configurar algunos de los parámetros DBMS y es posible que se DETENGA y REINICIE el DBMS para garantizar que DBMS pueda operar con el procedimiento almacenado en archivos jar. Si le preocupan los scripts, ¡no deje de revisarlos antes de ejecutarlos!) Ejecute start.bat en las plataformas Windows. En las plataformas Linux, use start.sh. Cuando la ejecución de este script haya concluido, usted debería poder observar algo similar a lo que aparece en la Figura 3 en su solicitud de comando o bash. (Ver una versión en formato de texto de los datos de salida de muestra en la Figura 3.)
Figura 3. Datos de salida de muestra del paquete JSONx
Datos de salida de muestra del paquete JSONx

En este momento, todo está configurado y usted puede observar los resultados de la consulta en la carpeta de datos de salida. Para verificar si los resultados creados son correctos, usted puede comparar los archivos de salida en la carpeta de datos de salida con los datos de salida de referencia que se ubican en la carpeta de referencia.

Si las muestras no se condicen con la carpeta de referencia, consulte el archivo de registro ubicado en el directorio de archivos de registro para encontrar lo que puede haber provocado el fracaso de la ejecución.

Para observar una ilustración de tweets de Twitter en XML amigable y en JSONx, ver el Anexo A.


Conclusión

En este artículo, se introdujo un formato nuevo (JSONx), que le permite almacenar JSON como XML en DB2 pureXML. También se describieron las diferencias entre JSONx y otros formatos amigables. Además, se discutió un típico caso de uso de JSON y se resaltaron los beneficios de usar pureXML para almacenar JSON. Por último, descargando un JSONx (el paquete JSONx), usted cuenta con todo lo necesario para crear aplicaciones JSON habilitadas en pureXML.

Los próximos dos artículos de esta serie se concentrarán en la exposición de la base de datos de muestra JSONx (creada en el paquete JSONx) por medio de JSON Universal Services y, luego de esto, se concentrarán en la creación del nivel de presentación con dispositivos Open-Social que se basan en JSON Universal Services como back-end.

Una posibilidad futura consiste en considerar diversas formas para que los desarrolladores Web puedan acceder a los documentos JSON (almacenados como JSONx) con JSONPath.


Agradecimientos

Queremos agradecer a Brien Muschett y William Palma por su colaboración.


Anexo A

Como se lo menciona en Un típico escenario JSON, muchos servicios web le ofrecen diversos formatos para visualizar la información. Los estándares industriales (como, por ejemplo, Atom y RSS, JSON o incluso las notaciones XML amigables) son ejemplos de estos formatos. Twitter le ofrece una API para acceder a tweets por ID. En este anexo, le mostramos los resultados de la emisión de dos solicitudes en Twitter usando curl: una en JSON y una en XML amigable. Luego de esto, le mostramos cómo convertir el XML amigable en JSONx.

En el Listado 11, usamos curl para llamar a la información relativa a un mensaje individual (el tweet cuya ID es 2311383114) que se posteó en twitter.com. Para recuperar la información del tweet (su Estado), usted puede invocar curl desde su terminal como en el Listado 11. Luego de esto, se devuelve el estado de dicho tweet en formato JSON. (Nota: La invocación de curl en los Listados 11 y 12 se divide en dos línea por cuestiones de formato.)

Listado 11. Recuperación del estatus con ID 2311383114 en 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" }

De manera alternativa, usted puede recuperar el mismo documento en Atom, RSS o en una notación XML amigable. En elListado 12, usted invoca la misma función para recuperar el estado. Pero en esta ocasión, usa la notación XML amigable:

Listado 12. Recuperación del estado con ID 2311383114 en formato XML amigable
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>

El Listado 13 muestra un ejemplo de invocación de DB2 UDF que convierte JSON en JSONx en los resultados que figuran en el Listado 12.

Listado 13. Representación en formato JSONx del documento JSON que apareció en el Listado 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>
lt;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
009</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>

Descargar

DescripciónNombretamaño
JSONx Bundlejsonx.zip145KB

Recursos

Aprender

Obtener los productos y tecnologías

Comentar

Comentarios

developerWorks: Ingrese

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


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

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

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Information mgmt
ArticleID=480372
ArticleTitle=Creación de una aplicación pureXML y JSON: Parte 1: Almacenamiento y consulta de JSON con DB2 pureXML
publish-date=07292011