Lectura: 4 minutos

1. Por qué este tema importa ahora

Oracle está moviendo a todo el mundo hacia Autonomous AI Database (23ai / 26ai) y el mensaje es claro: la IA ya no vive sólo en el app server, ahora vive dentro de la base de datos. Para los que venimos de PL/SQL esto es oro, porque por primera vez podemos usar lenguaje natural para generar SQL, validarlo y ejecutarlo dentro de un flujo PL/SQL sin tener que brincar a Python o a un microservicio externo.

La pregunta es: ¿cómo hago que mi paquete PL/SQL siga mandando, pero con IA debajo? La respuesta corta: DBMS_CLOUD_AI + Select AI.

2. Qué es Select AI

Select AI es la capacidad del Autonomous AI Database para recibir una instrucción en lenguaje natural (“muéstrame las 10 facturas más recientes del cliente ACME”) y convertirla en una sentencia SQL válida contra tu esquema. El motor consulta el diccionario, entiende el contexto, genera el SQL y puede devolverlo o ejecutarlo. Todo eso, sin que tú escribas el SELECT.

El truco es que eso también lo puedes invocar desde PL/SQL, y ahí es donde entra DBMS_CLOUD_AI.

3. Arquitectura mínima

• Usuario / App / APEX manda una instrucción en lenguaje natural (texto libre).
• Paquete PL/SQL recibe el texto y llama a DBMS_CLOUD_AI.GENERATE_SQL(...).
• El motor LLM de Oracle genera el SQL.
• El paquete valida, aplica controles de seguridad (whitelist de tablas, esquema permitido, límites de filas) y recién ahí ejecuta el SQL generado.
• Se devuelve el resultado a APEX o a la app móvil.

Así mantienes el control en PL/SQL, pero le das superpoderes de IA.

4. Configuración previa

Antes de hacer magia necesitas:

1. Autonomous AI Database o Autonomous Database con Select AI habilitado.
2. Permisos para invocar DBMS_CLOUD_AI (rol adecuado en el entorno OCI/Autonomous).
3. Definir el modelo/endpoint que vas a usar. Oracle te deja apuntar a modelos propios o a los que estén expuestos por el servicio de IA.
4. Tener claro qué esquemas y qué tablas quieres que el LLM pueda usar. Esto es seguridad, no es opcional.

5. Patrón básico en PL/SQL

La mayoría de los ejemplos que ves ejecutan directo el SQL generado. Nosotros no vamos a hacer eso. Vamos a generar, inspeccionar y recién luego ejecutar.

create or replace package ai_query_pkg as
    function run_nl_query(p_prompt in varchar2) return sys_refcursor;
end ai_query_pkg;
/

create or replace package body ai_query_pkg as

    function run_nl_query(p_prompt in varchar2) return sys_refcursor is
        l_sql     clob;
        l_rc      sys_refcursor;
    begin
        l_sql := dbms_cloud_ai.generate_sql(
            model_name => 'oci://genai.large.sql',
            prompt     => p_prompt
        );

        if not security_guard(l_sql) then
            raise_application_error(-20001, 'SQL generated is not allowed');
        end if;

        open l_rc for l_sql;
        return l_rc;
    end run_nl_query;

    function security_guard(p_sql in clob) return boolean is
    begin
        if regexp_like(p_sql, '(^|\s)(dba_|v\$|gv\$)', 'i') then
            return false;
        end if;
        if regexp_like(p_sql, '(^|\s)delete\s', 'i') then
            return false;
        end if;
        if regexp_like(p_sql, '(^|\s)update\s', 'i') then
            return false;
        end if;
        return true;
    end;

end ai_query_pkg;
/

Puntos importantes para tu equipo:

• El código está en inglés, como debe ser.
• No ejecutamos ciegamente lo que devuelve la IA.
• Metimos una capa de seguridad mínima. En productivo la vuelves una tabla de reglas.

6. Endpoints y prompts inteligentes

El prompt que mandas a DBMS_CLOUD_AI no tiene que ser sólo “dame las ventas”. Puedes ser más agresivo y mandar contexto de negocio para que el modelo genere mejor SQL. Ejemplo:

declare
    l_sql clob;
begin
    l_sql := dbms_cloud_ai.generate_sql(
        model_name => 'oci://genai.large.sql',
        prompt     => 'You are a senior Oracle database developer. Use only tables from schema ERP. Return top 20 invoices from last month with customer name and total amount, ordered by total amount desc.'
    );
    dbms_output.put_line(l_sql);
end;
/

Con esto obligas al modelo a mirar sólo tu esquema y reduces SQL raros.

7. Integración con APEX

Si estás en APEX es todavía más sencillo. El flujo es:

1. Creas una página con un text area para la consulta en lenguaje natural.
2. Llamas a un proceso PL/SQL que invoca ai_query_pkg.run_nl_query(:PXX_PROMPT).
3. Ese proceso devuelve un sys_refcursor que APEX puede mostrar en un Interactive Report o en un Classic Report usando una función.
4. Registras en una tabla de auditoría qué prompt pidió qué usuario, qué SQL se generó y cuántas filas devolvió.

Tabla sencilla de auditoría:

create table ai_query_audit (
    id              number generated by default on null as identity primary key,
    username        varchar2(100),
    prompt_text     clob,
    generated_sql   clob,
    exec_ts         timestamp default systimestamp,
    rowcount        number,
    ok              varchar2(1)
);

Y dentro del paquete:

procedure log_query(
    p_user in varchar2,
    p_prompt in clob,
    p_sql in clob,
    p_rowcount in number,
    p_ok in varchar2
) is
begin
    insert into ai_query_audit(username, prompt_text, generated_sql, rowcount, ok)
    values (p_user, p_prompt, p_sql, p_rowcount, p_ok);
end;

Con esto puedes mostrarle al CISO qué se está preguntando y qué se está ejecutando.

8. Gobernanza: PL/SQL sigue mandando

Lo moderno aquí no es que PL/SQL ejecute IA. Lo moderno es que PL/SQL se quede como el orquestador de:

• Qué modelo se usa.
• Contra qué esquema puede consultar.
• Qué tablas nunca se tocan.
• Cuántas filas máximas puede traer una consulta generada por IA.

Puedes llevar esas reglas a una tabla:

create table ai_query_rules (
    rule_id         number generated always as identity primary key,
    rule_name       varchar2(100) not null,
    rule_type       varchar2(30)  not null,  -- TABLE_DENY, SCHEMA_ALLOW, MAX_ROWS
    rule_value      varchar2(200) not null
);

Y tu función security_guard puede leer estas reglas en lugar de tenerlas quemadas. Eso te da flexibilidad para cada cliente/tenant.

9. Extenderlo a RAG dentro de Oracle

En Autonomous AI Database ya tienes AI Vector Search. Eso significa que puedes hacer un pipeline:

1. Usuario escribe: “muéstrame las órdenes con riesgo de fraude de la última semana”.
2. PL/SQL manda a Select AI.
3. Select AI genera un SQL que a su vez llama una función que hace similarity search contra tus vectores.
4. Devuelves el resultado como si fuera un SELECT normal.

Esto te permite decirle al negocio: “no sólo hablamos SQL, hablamos conocimiento”. Y todo dentro de la base.

10. Qué NO debes permitir

• Que el modelo genere DDL o DML libre y lo ejecutes directo.
• Que pregunte vistas de diccionario sensibles (DBA_USERS, DBA_TAB_PRIVS, etc.).
• Que no haya auditoría de los prompts.
• Que el usuario final pueda cambiar el model_name.

Si dejas eso abierto, rompes el discurso de seguridad que vendes a tus clientes.

11. Conclusión

PL/SQL no está viejo. Lo que está viejo es usarlo como si estuviéramos en 2005. Si la base ahora trae un LLM adentro, entonces el PL/SQL se tiene que volver el director técnico: él decide qué se ejecuta, cuánto, contra qué esquema y quién lo pidió. Si tú haces esto hoy, llegas a la conversación de AI en las empresas sin tener que reescribir todo en Python. Y eso te pone adelante.

---

Referencias

Oracle. (2025). Autonomous Database Select AI overview. Oracle Help Center. https://docs.oracle.com/

Oracle. (2025). DBMS_CLOUD_AI package (Autonomous Database). Oracle Help Center. https://docs.oracle.com/

Oracle. (2025). Using AI Vector Search in Autonomous Database. Oracle Help Center. https://docs.oracle.com/

Oracle. (2024). Build AI-powered apps with Oracle Database 23ai. Oracle Technical Resources. https://www.oracle.com/

Fowler, M. (2024). Practical patterns for LLM to SQL in enterprise databases. ThoughtWorks Insights. https://www.thoughtworks.com/