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 120Da 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 TRUEPodemos 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 TRUEO 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)
-----------
TRUEO 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:00Role 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)
------------
120Esse 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_INSTReREGEXP_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,XMLQUERYeXMLTABLE. - 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_DSINTERVALeTO_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
