Trabalhando com JSON em PL/SQL

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (3)  (0)

Veja neste artigo a apresentação da biblioteca independente “Librairie-JSON” que possibilita a manipulação de JSON na linguagem PL/SQL do SGBD Oracle. O artigo descreve o processo de obtenção e instalação da biblioteca e a sua forma básica de us

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.

Conteúdo do arquivo ZIP

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
Execução do script de criação do cabeçalho do package no SQL Developer

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
Execução do script de criação do corpo do package no SQL Developer (clique em Cancelar)

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.

Resultado da execução da procedure Oracle2JSON

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.

Resultado da execução da procedure JSON2Oracle

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!

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?