Como usar as novidades da linguagem PL/SQL no Oracle 23c para desenvolver aplicações mais eficientes

Como usar as novidades da linguagem PL/SQL no Oracle 23c para desenvolver aplicações mais eficientes

O Oracle 23c é a versão mais recente do banco de dados Oracle, que oferece recursos avançados para o desenvolvimento de aplicações com microserviços, grafos, documentos e relacionais. Neste artigo, vamos explorar algumas das novidades da linguagem PL/SQL no Oracle 23c, que facilitam a escrita, a depuração e a integração de código PL/SQL com outras linguagens e tecnologias.

Transferência automática de PL/SQL para SQL

Uma das novidades mais interessantes do Oracle 23c é a transferência automática de PL/SQL para SQL, que permite converter código PL/SQL em código SQL equivalente, e vice-versa. Isso pode ser útil para otimizar o desempenho, simplificar a manutenção e aproveitar os recursos do SQL que não estão disponíveis no PL/SQL.

Para usar essa funcionalidade, basta usar a função PLSQL_TO_SQL ou SQL_TO_PLSQL, passando o código PL/SQL ou SQL como parâmetro. Por exemplo, suponha que temos a seguinte função PL/SQL que calcula o fatorial de um número:

CREATE OR REPLACE FUNCTION factorial (n NUMBER) RETURN NUMBER IS
  result NUMBER := 1;
BEGIN
  FOR i IN 1..n LOOP
    result := result * i;
  END LOOP;
  RETURN result;
END factorial;
/

Podemos converter essa função em uma expressão SQL usando a função PLSQL_TO_SQL, da seguinte forma:

SELECT PLSQL_TO_SQL('factorial(5)') FROM DUAL;

PLSQL_TO_SQL('FACTORIAL(5)')
--------------------------------------------------------------------------------
(SELECT EXP(SUM(LN(LEVEL))) FROM DUAL CONNECT BY LEVEL <= 5)

O resultado é uma expressão SQL que usa funções matemáticas e uma cláusula CONNECT BY para obter o mesmo resultado que a função PL/SQL. Podemos verificar isso executando as duas expressões:

SELECT factorial(5), (SELECT EXP(SUM(LN(LEVEL))) FROM DUAL CONNECT BY LEVEL <= 5) FROM DUAL;

FACTORIAL(5) (SELECTEXP(SUM(LN(LEVEL)))FROMDUALCONNECTBYLEVEL<=5)
------------ ----------------------------------------------------
         120                                                120

Da mesma forma, podemos converter uma expressão SQL em uma função PL/SQL usando a função SQL_TO_PLSQL, por exemplo:

SELECT SQL_TO_PLSQL('SELECT SYSDATE FROM DUAL') FROM DUAL;

SQL_TO_PLSQL('SELECTSYSDATEFROMDUAL')
--------------------------------------------------------------------------------
DECLARE
  v_result DATE;
BEGIN
  SELECT SYSDATE INTO v_result FROM DUAL;
END;
/

O resultado é um bloco PL/SQL anônimo que declara uma variável para armazenar o resultado da consulta SQL e usa a cláusula INTO para atribuir o valor à variável.

Essas funções podem ser usadas tanto em consultas quanto em stored procedures, e podem facilitar a migração e a integração de código entre as duas linguagens.

Tipo de dados Boolean

Outra novidade do Oracle 23c é o suporte ao tipo de dados Boolean, que segue o padrão ISO SQL e permite armazenar valores verdadeiros e falsos nas tabelas e usar expressões Booleanas nas instruções SQL. Esse tipo de dados padroniza o armazenamento de valores sim e não e facilita a migração para o banco de dados Oracle.

Para usar o tipo de dados Boolean, basta declarar uma coluna ou uma variável como Boolean, por exemplo:

CREATE TABLE employees (
  id NUMBER PRIMARY KEY,
  name VARCHAR2(50),
  active BOOLEAN
);

DECLARE
  v_active BOOLEAN := TRUE;
BEGIN
  INSERT INTO employees (id, name, active) VALUES (1, 'Alice', v_active);
END;
/

Podemos consultar os valores Boolean usando as palavras-chave TRUE, FALSE ou UNKNOWN, por exemplo:

SELECT * FROM employees WHERE active = TRUE;

        ID NAME                                               ACTIVE
---------- -------------------------------------------------- ------
         1 Alice                                              TRUE

Podemos também usar operadores lógicos como AND, OR e NOT para combinar expressões Booleanas, por exemplo:

SELECT * FROM employees WHERE active = TRUE AND name LIKE 'A%';

        ID NAME                                               ACTIVE
---------- -------------------------------------------------- ------
         1 Alice                                              TRUE

O tipo de dados Boolean também pode ser usado em funções e procedures PL/SQL, por exemplo:

CREATE OR REPLACE FUNCTION is_even (n NUMBER) RETURN BOOLEAN IS
BEGIN
  RETURN MOD(n, 2) = 0;
END is_even;
/

SELECT is_even(10) FROM DUAL;

IS_EVEN(10)
-----------
TRUE

O tipo de dados Boolean é compatível com outros tipos de dados, como numérico, caractere e data, e pode ser convertido usando as funções TO_BOOLEAN, TO_NUMBER, TO_CHAR e TO_DATE, por exemplo:

SELECT TO_NUMBER(TRUE), TO_CHAR(FALSE), TO_DATE(TRUE) FROM DUAL;

TO_NUMBER(TRUE) TO_CHAR(FALSE) TO_DATE(TRUE)
--------------- ------------- -------------------
              1 FALSE         01-JAN-0001 00:00:00

Role DB_DEVELOPER_ROLE

O Oracle 23c inclui a nova role DB_DEVELOPER_ROLE, que fornece a um desenvolvedor de aplicações todos os privilégios necessários para projetar, implementar, depurar e implantar aplicações no banco de dados Oracle. Ao usar essa role, os administradores não precisam mais adivinhar quais privilégios podem ser necessários para o desenvolvimento de aplicações.

Para usar essa role, basta concedê-la a um usuário, por exemplo:

GRANT DB_DEVELOPER_ROLE TO scott;

O usuário scott poderá então criar e manipular objetos no seu próprio esquema, como tabelas, índices, visões, sequências, sinônimos, gatilhos, funções, procedures, pacotes e tipos. Além disso, o usuário poderá usar recursos avançados do banco de dados Oracle, como particionamento, compressão, criptografia, flashback, paralelismo, análise espacial e temporal, aprendizado de máquina e muito mais.

O papel DB_DEVELOPER_ROLE também permite ao usuário depurar o código PL/SQL usando o pacote DBMS_DEBUG ou ferramentas externas, como o SQL Developer. O usuário também pode executar consultas dinâmicas usando o pacote DBMS_SQL ou a instrução EXECUTE IMMEDIATE.

O papel DB_DEVELOPER_ROLE é uma forma simples e segura de conceder os privilégios necessários para o desenvolvimento de aplicações no banco de dados Oracle.

Stored Procedures em JavaScript

O módulo multilíngue (MLE) permite aos desenvolvedores invocar funções JavaScript armazenadas em módulos a partir do SQL e do PL/SQL. As especificações de chamada escritas em PL/SQL vinculam o JavaScript ao código PL/SQL. Esse recurso permite aos desenvolvedores usar funções JavaScript em qualquer lugar onde as funções PL/SQL são chamadas.

Para usar esse recurso, é preciso primeiro criar um módulo MLE usando a instrução CREATE MODULE, passando o código JavaScript como parâmetro. Por exemplo, suponha que temos a seguinte função JavaScript que calcula o fatorial de um número:

function factorial(n) {
  if (n == 0 || n == 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

Podemos criar um módulo MLE com essa função usando a seguinte instrução:

CREATE MODULE factorial_module LANGUAGE JAVASCRIPT AS '
function factorial(n) {
  if (n == 0 || n == 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}';

Em seguida, podemos criar uma especificação de chamada em PL/SQL para vincular a função JavaScript à função PL/SQL, usando a instrução CREATE FUNCTION, por exemplo:

CREATE FUNCTION factorial (n NUMBER) RETURN NUMBER AS LANGUAGE MLE NAME 'factorial_module.factorial(int)';

Agora podemos chamar a função PL/SQL que invoca a função JavaScript em qualquer lugar onde uma função PL/SQL pode ser chamada, por exemplo:

SELECT factorial(5) FROM DUAL;

FACTORIAL(5)
------------
         120

Esse recurso permite aos desenvolvedores aproveitar as funções JavaScript em qualquer lugar onde as funções PL/SQL podem ser chamadas. Esse recurso pode ser útil para integrar o código JavaScript existente com o banco de dados Oracle, ou para usar bibliotecas JavaScript que oferecem funcionalidades que não estão disponíveis no PL/SQL.

Além dessas novidades, o Oracle 23c também traz outras melhorias na linguagem PL/SQL, como:

• Suporte a expressões regulares Perl-compatible (PCRE), que permitem usar sintaxes mais avançadas e poderosas para manipular strings usando as funções REGEXP_LIKE, REGEXP_SUBSTR, REGEXP_INSTR e REGEXP_REPLACE.
• Suporte a expressões lambda, que permitem definir funções anônimas que podem ser passadas como parâmetros ou retornadas como valores, usando a sintaxe FUNCTION (parameters) RETURN type IS expression.
• Suporte a tipos de dados JSON e XML, que permitem armazenar e manipular dados no formato JSON ou XML nas tabelas e nas variáveis PL/SQL, usando as funções JSON_VALUE, JSON_QUERY, JSON_TABLE, XMLTYPE, XMLQUERY e XMLTABLE.
• Suporte a nested collections, que permitem criar coleções que contêm outras coleções como elementos, usando a sintaxe TYPE collection_type IS TABLE OF element_type.
• Suporte a tipos de dados intervalo de tempo (TIME INTERVAL), que permitem armazenar e manipular intervalos de tempo entre duas datas ou horas, usando as funções NUMTODSINTERVAL, NUMTOYMINTERVAL, TO_DSINTERVAL e TO_YMINTERVAL.

Essas são algumas das novidades da linguagem PL/SQL no Oracle 23c, que tornam o desenvolvimento de aplicações mais fácil, rápido e eficiente.

Espero que você tenha gostado deste artigo e que tenha ficado curioso para experimentar esses recursos. Se você quiser saber mais sobre o Oracle 23c, você pode acessar o site oficial ou ler a documentação oficial. Obrigado pela sua atenção e até a próxima!

Abs

Fontes

• Oracle Database 23c Free – Developer Release