1. Introdução
A crescente popularização do modelo JSON como formato para representação e transmissão de informações (especialmente em aplicações AJAX) motivou o surgimento de uma enorme coleção de bibliotecas para realizar o parsing de dados estruturados de acordo com esta sintaxe (confira a lista em www.json.org). Curiosamente, a maioria destas bibliotecas foi desenvolvida por programadores independentes, com o uso das mais distintas abordagens, e para as mais diversas linguagens de programação: ASP, C, C++, C#, Delphi, Java, Lisp, Lua, Matlab, Perl, PHP, PL/SQL, Prolog, Python, R, Ruby, Visual Basic, entre outras.
Este artigo aborda a biblioteca “Librairie-JSON” que possibilita o processamento de JSON na linguagem PL/SQL. Na verdade, trata-se de um package PL/SQL bastante simples, que pode ser utilizado de forma livre por qualquer programador. Ele oferece métodos para converter uma string codificada em JSON para uma variável PL/SQL e também de realizar a operação oposta (converter uma variável PL/SQL para uma string codificada em JSON).
É importante esclarecer que a biblioteca não foi desenvolvida pela Oracle, mas sim por um programador independente. Conforme comentamos no início do artigo, esta ainda é a situação mais comum no “mundo JSON” – os desenvolvedores independentes correndo mais rápido do que as empresas! Desta forma, enquanto a Oracle não disponibilizar uma biblioteca oficial, a utilização de uma biblioteca independente é a única alternativa de que dispomos.
2. Download e Instalação
Para realizar o download e instalação do package, execute as etapas a seguir:
Passo 1: acesse o site do projeto, http://reseau.erasme.org/Librairie-JSON (não se assuste com o texto em Francês!), e efetue o download do arquivo ZIP contendo a versão mais recente da biblioteca (versão 1.1 no momento em que este artigo era elaborado).
Passo 2: descompacte o ZIP em uma pasta de trabalho de seu computador (ex: C:\TEMP). Conforme mostra a Figura 1, serão extraídos dois arquivos: “JSON.pks” e “JSON.pkb”. O primeiro contém o script para a criação do cabeçalho do package o segundo o script com o corpo do package.
Figura 1: Conteúdo do arquivo ZIP
Passo 3: utilizando o SQL*Plus ou o SQL Developer, efetue o login em um banco (usuário) Oracle para que você possa instalar a biblioteca. Na verdade essa instalação consiste simplesmente em rodar os scripts “JSON.pks” e “JSON.pkb”, para que estes efetuem a criação de um package denominado “JSON” no banco de dados. Após o package ser criado, você poderá utilizar os seus métodos em qualquer programa PL/SQL que esteja criado no banco. IMPORTANTE: para rodar o script, você precisa utilizar logar com um usuário Oracle que tenha o direito de criação de objetos do tipo package!
Passo 4: primeiro execute o script “JSON.pks”. Considerando que o arquivo esteja armazenado na pasta “C:\TEMP”, basta executar a linha de comando mostrada na Listagem 1. Isso é feito de forma direta no SQL*Plus. Já para rodar no SQL Developer, você deve abrir uma janela de script, digitar a linha de comando e clicar no botão destacado no círculo vermelho na Figura 2.
Listagem 1: Linha de comando para execução do script que cria o cabeçalho do package JSON
@c:\temp\JSON.pks
PACKAGE JSON compilado
Figura 2: Execução do script de criação do cabeçalho do package no SQL Developer
Passo 5: A seguir, execute o script “JSON.pkb”, responsável pela criação do corpo do package (Listagem 2). No SQL Developer, durante o processo de compilação, é possível que apareça uma janela “estranha” solicitando um valor para a variável P_RENDERTYPE (Figura 3). Nesse caso, simplesmente clique em Cancelar.
Listagem 2: Execução do script para criação do corpo do package JSON
@c:\temp\JSON.pkb
PACKAGE BODY JSON compilado
Figura 3: Execução do script da listagem 2 no SQL Developer (clique em Cancelar)
3. Utilizando o Package JSON
Após a criação do package JSON, você poderá utilizá-lo dentro de qualquer função, procedure ou package criado em seu banco Oracle. O package JSON oferece dois tipos principais lidar com a sintaxe JSON: JSONStructObj (uma variável deste tipo armazena um objeto JSON) e JSONArray (armazena um array JSON). Cada par “nome/valor” é adicionado a uma variável do tipo “JSONStructObj” com o uso do método addAttr e pode ser extraído com o uso do método getAttrValue.
Na Listagem 3 apresentamos a procedure “ORACLE2JSON”, que representa um exemplo de programa que converter uma variável PL/SQL (do tipo “JSONStructObj”) para uma string codificada em JSON. No exemplo apresentado, criamos uma variável PL/SQL contendo informações sobre um filme (título, ano e gêneros). A explicação sobre o funcionamento do programa é apresentada nos comentários dentro do código.
Listagem 3: Procedure ORACLE2JSON - Convertendo variável PL/SQL para uma string JSON
create or replace PROCEDURE ORACLE2JSON AS
my_movie_obj JSON.JSONStructObj; /* Objeto -> informações de um filme */
my_array JSON.JSONArray; /* Array com os gêneros do filme */
string_json VARCHAR2(1000); /* receberá conteúdo do objeto
"convertido" para JSON */
BEGIN
/* instancia o objeto JSON "my_movie" */
JSON.newJSONObj(my_movie_obj);
/* adiciona o título e ano do filme ao objeto
com o uso do método "addAttr" */
my_movie_obj := JSON.addAttr(my_movie_obj, 'titulo', 'JSON x XML');
my_movie_obj := JSON.addAttr(my_movie_obj, 'ano', '2012');
/* adiciona os gêneros ao vetor "my_array" */
my_array(1):= 'Aventura';
my_array(my_array.last+1):= 'Ação';
my_array(my_array.last+1):= 'Ficção';
/* adiciona o vetor "my_array" ao objeto "my_movie" com o uso dos métodos
"addAttr" e "addArray" e com o nome de "generos". */
my_movie_obj := JSON.addAttr(my_movie_obj, 'generos', JSON.addArray(my_array));
/* encerra a configuração do objeto "my_movie" */
JSON.closeJSONObj(my_movie_obj);
/* utiliza o método JSON2String para converter o conteúdo do objeto my_movie
para uma string com a sintaxe JSON. */
string_json := JSON.JSON2String(my_movie_obj);
/* imprime o valor da string com a sintaxe JSON */
DBMS_OUTPUT.PUT_LINE(string_json);
END ORACLE2JSON;
Para rodar o programa, digite EXEC ORACLE2JSON. Não esqueça de ligar a saída do console, utilizando o comando SET SERVEROUT ON no SQL*Plus ou abrindo uma janela de saída DMBS caso você esteja executando o SQL Developer. O resultado da execução do programa é apresentado na Figura 4.
Figura 4: Resultado da execução da procedure Oracle2JSON
IMPORTANTE: Observando a Figura 4, podemos observar que o resultado está correto. Porém, existe um certo “desrespeito” com a sintaxe do JSON, pois os nomes das variáveis e os valores do tipo string foram envolvidos por aspas simples ao invés de aspas duplas. Felizmente é fácil corrigir esse comportamento: basta editar o script de criação do cabeçalho do package (“JSON.pks”) e modificar o valor do parâmetro g_stringDelimiter para aspas duplas (veja as duas últimas linhas mostradas na Listagem 4). Depois disso, basta recompilar os arquivos “JSON.pks” e “JSON.pkb” da forma descrita na Seção 3.
Listagem 4: Correção no Script JSON.pks
...
--------------------------------------------------------------------------------
-- Global variables and constants
--------------------------------------------------------------------------------
-- Package Version
g_package_version constant varchar2(100) := '1.1';
...
--g_stringDelimiter varchar2(1) := ''''; -- comentado aqui
g_stringDelimiter varchar2(1) := '"'; -- inserido aqui
...
Para finalizar esta seção sobre a utilização do package, na Listagem 5 apresentamos a procedure “JSON2ORACLE” que consiste em um exemplo do “caminho inverso”: desta vez, o programa analisa uma string codificada em JSON e converte-a para uma variável PL/SQL, do tipo “JSONStructObj”. A explicação sobre o funcionamento do programa é novamente descrita nos comentários dentro do código.
Listagem 5: Procedure JSON2Oracle - Convertendo uma string JSON para um objeto PL/SQL
create or replace procedure JSON2ORACLE AS
my_jason_str VARCHAR2(2000); /* string codificada em JSON com
informações de um filme */
my_movie_obj JSON.JSONStructObj; /* variável PL/SQL que receberá o conteúdo
da string JSON */
BEGIN
/* cria a string codificada em JSON para armazenar informações de um filme */
my_jason_str := '{"titulo":"JSON James","ano":2012,"generos":["Western","Ação"]}';
/* chama o método "String2SJSON" para converter a string em
um objeto "JSONStructObj" */
my_movie_obj := JSON.String2JSON(my_jason_str, '"');
/* recupera e imprime cada atributo de "my_movie_obj"
utilizando o método "getAttrValue" */
DBMS_OUTPUT.PUT_LINE('Recuperando o atributo "ano" com getAttrValue() : ');
DBMS_OUTPUT.PUT_LINE(JSON.getAttrValue(my_movie_obj, 'ano'));
DBMS_OUTPUT.PUT_LINE('Recuperando o atributo "titulo" com getAttrValue() : ');
DBMS_OUTPUT.PUT_LINE(JSON.getAttrValue(my_movie_obj, 'titulo'));
DBMS_OUTPUT.PUT_LINE('Recuperando o atributo "generos" com getAttrValue() : ');
DBMS_OUTPUT.PUT_LINE(JSON.getAttrValue(my_movie_obj, 'generos'));
END JSON2ORACLE;
O resultado da execução do programa é apresentado na Figura 5.
Figura 5: Resultado da execução da procedure JSON2Oracle
4. Conclusões e Comentários Finais
Este artigo apresentou a biblioteca “Librairie-JSON” que permite o processamento de JSON em programas PL/SQL. O artigo descreveu os passos para a sua obtenção e instalação e apresentou exemplos básicos de utilização da biblioteca.
Embora a biblioteca seja, na verdade, apenas um pequeno programa open source “não oficial” (não foi desenvolvida pela Oracle), acreditamos que ela demonstre-se potencialmente útil em situações práticas, especialmente porque a Oracle ainda não desenvolveu nenhum package para a manipulação de JSON. Desta forma, se você precisar lidar com JSON em PL/SQL vale a pena avaliar essa biblioteca tão simples de ser instalada e utilizada (ou então, você precisará escrever o seu próprio código para fazer o parsing de JSON).
Também é importante comentar que existem outras bibliotecas independentes para tratar JSON em PL/SQL, dentre elas a “pljson”, que assim como a “Librairie-JSON” faz parte da relação de bibliotecas relacionadas no site www.json.org. Um abraço e até a próxima!
