37.11. Conversão do PL/SQL do Oracle para o PL/pgSQL do PostgreSQL

Exemplo 37-6. Conversão de uma função simples de PL/SQL para PL/pgSQL

Abaixo está uma função escrita na linguagem PL/SQL do Oracle:

CREATE OR REPLACE FUNCTION cs_fmt_browser_version
(v_nome IN varchar, v_versao IN varchar)
RETURN varchar IS
BEGIN
    IF v_versao IS NULL THEN
       RETURN v_nome;
    END IF;
    RETURN v_nome || '/' || v_versao;
END;
/
show errors;

Vamos examinar esta função para ver as diferenças com relação à linguagem PL/pgSQL:

• O PostgreSQL não possui parâmetros com nome. Deve ser criado um aliás explícito dentro da função.
• O Oracle permite que sejam passados parâmetros IN, OUT e INOUT para as funções. Por exemplo, INOUT significa que o parâmetro recebe um valor e retorna outro. O PostgreSQL somente possui parâmetros IN e, portanto, não há especificação do tipo do parâmetro.
• A palavra chave RETURN no protótipo da função (não no corpo da função), no PostgreSQL se torna RETURNS.
• No PostgreSQL as funções são criadas utilizando apóstrofos como delimitadores do corpo da função e, portanto, há necessidade de criar seqüências de escape para os apóstrofos dentro do corpo da função.
• Não existe o comando /show errors no PostgreSQL, e não há necessidade uma vez que os erros são relatados automaticamente.

Abaixo está mostrado como esta função deve se parecer após ser convertida para o PostgreSQL: [1]

CREATE OR REPLACE FUNCTION cs_fmt_browser_version(varchar, varchar)
RETURNS varchar AS '
DECLARE
    v_nome   ALIAS FOR $1;
    v_versao ALIAS FOR $2;
BEGIN
    IF v_versao IS NULL THEN
       return v_nome;
    END IF;
    RETURN v_nome || ''/'' || v_versao;
END;
' LANGUAGE plpgsql;

Exemplo 37-7. Conversão de uma função que cria outra função de PL/SQL para PL/pgSQL

O procedimento abaixo obtém linhas a partir de uma instrução SELECT, e constrói uma função grande com os resultados em instruções IF, por motivo de eficiência. Em particular, deve ser observada a diferença entre o cursor e o laço FOR.

Esta é a versão Oracle:

CREATE OR REPLACE PROCEDURE cs_update_referrer_type_proc IS
    CURSOR referrer_keys IS
        SELECT * FROM cs_referrer_keys
        ORDER BY try_order;

    a_output VARCHAR(4000);
BEGIN
    a_output := 'CREATE OR REPLACE FUNCTION cs_find_referrer_type
(v_host IN VARCHAR, v_domain IN VARCHAR,
v_url IN VARCHAR) RETURN VARCHAR IS BEGIN';

    FOR referrer_key IN referrer_keys LOOP
        a_output := a_output || ' IF v_' || referrer_key.kind ||
                    ' LIKE ''' || referrer_key.key_string ||
                    ''' THEN RETURN ''' ||
                    referrer_key.referrer_type || '''; END IF;';
    END LOOP;

    a_output := a_output || ' RETURN NULL; END;';
    EXECUTE IMMEDIATE a_output;
END;
/
show errors;

Abaixo está mostrado como esta função ficaria no PostgreSQL:

CREATE FUNCTION cs_update_referrer_type_proc() RETURNS integer AS '
DECLARE
    referrer_keys RECORD;  -- Registro genérico para ser utilizado no FOR
    a_output varchar(4000);
BEGIN
    a_output := ''CREATE FUNCTION cs_find_referrer_type(varchar, varchar, varchar)
                  RETURNS varchar AS ''''
                     DECLARE
                         v_host ALIAS FOR $1;
                         v_domain ALIAS FOR $2;
                         v_url ALIAS FOR $3;
                     BEGIN '';

    -- Observe como os resultados da consulta podem ser varridos no laço FOR
    -- utilizando a construção FOR <record>.

    FOR referrer_keys IN SELECT * FROM cs_referrer_keys ORDER BY try_order LOOP
        a_output := a_output || '' IF v_'' || referrer_keys.kind
                 || '' LIKE ''''''''''
                 || referrer_keys.key_string
                 || '''''''''' THEN RETURN ''''''
                 || referrer_keys.referrer_type
                 || ''''''; END IF;'';
    END LOOP;

    a_output := a_output || '' RETURN NULL; END; '''' LANGUAGE plpgsql;'';

    -- EXECUTE funciona porque não há substituição de variáveis,
    -- senão iria falhar. Veja em PERFORM outra maneira de executar funções.

    EXECUTE a_output;
END;
' LANGUAGE plpgsql;

Exemplo 37-8. Conversão de um procedimento com manipulação de cadeia de caracteres e parâmetros OUT de PL/SQL para PL/pgSQL

O procedimento mostrado abaixo, escrito na linguagem PL/SQL do Oracle, é utilizado para analisar uma URL e retornar vários elementos (hospedeiro, caminho e comando). As funções escritas em PL/pgSQL podem retornar apenas um valor. No PostgreSQL uma forma de resolver este problema é dividir o procedimento em três funções diferentes: uma para retornar o hospedeiro, outra o caminho e mais uma para a consulta.

Esta é a versão Oracle:

CREATE OR REPLACE PROCEDURE cs_parse_url(
    v_url   IN  VARCHAR,  -- Parâmetro de entrada
    v_host  OUT VARCHAR,  -- Parâmetro de saída
    v_path  OUT VARCHAR,  -- Parâmetro de saída
    v_query OUT VARCHAR)  -- Parâmetro de saída
IS
    a_pos1 INTEGER;
    a_pos2 INTEGER;
BEGIN
    v_host  := NULL;
    v_path  := NULL;
    v_query := NULL;
    a_pos1  := instr(v_url, '//');

    IF a_pos1 = 0 THEN
        RETURN;
    END IF;
    a_pos2 := instr(v_url, '/', a_pos1 + 2);
    IF a_pos2 = 0 THEN
        v_host := substr(v_url, a_pos1 + 2);
        v_path := '/';
        RETURN;
    END IF;

    v_host := substr(v_url, a_pos1 + 2, a_pos2 - a_pos1 - 2);
    a_pos1 := instr(v_url, '?', a_pos2 + 1);

    IF a_pos1 = 0 THEN
        v_path := substr(v_url, a_pos2);
        RETURN;
    END IF;

    v_path := substr(v_url, a_pos2, a_pos1 - a_pos2);
    v_query := substr(v_url, a_pos1 + 1);
END;
/
show errors;

Abaixo está mostrado como uma função em PL/pgSQL para retornar a parte do hospedeiro poderia se parecer:

CREATE OR REPLACE FUNCTION cs_parse_url_host(varchar) RETURNS varchar AS '
DECLARE
    v_url  ALIAS FOR $1;
    v_host varchar;
    v_path varchar;
    a_pos1 integer;
    a_pos2 integer;
    a_pos3 integer;
BEGIN
    v_host := NULL;
    a_pos1 := instr(v_url, ''//'');

    IF a_pos1 = 0 THEN
        RETURN '''';  -- Retornar uma cadeia de caracteres vazia
    END IF;

    a_pos2 := instr(v_url,''/'',a_pos1 + 2);
    IF a_pos2 = 0 THEN
        v_host := substr(v_url, a_pos1 + 2);
        v_path := ''/'';
        RETURN v_host;
    END IF;

    v_host := substr(v_url, a_pos1 + 2, a_pos2 - a_pos1 - 2 );
    RETURN v_host;
END;
' LANGUAGE plpgsql;

Exemplo 37-9. Conversão de um procedimento de PL/SQL para PL/pgSQL

A versão Oracle:

CREATE OR REPLACE PROCEDURE cs_create_job(v_job_id IN INTEGER) IS
    a_running_job_count INTEGER;
    PRAGMA AUTONOMOUS_TRANSACTION;
(1)

BEGIN
    LOCK TABLE cs_jobs IN EXCLUSIVE MODE;
(2)


    SELECT count(*)
    INTO   a_running_job_count
    FROM   cs_jobs
    WHERE  end_stamp IS NULL;

    IF a_running_job_count > 0 THEN
        COMMIT; -- liberar bloqueio
(3)

        raise_application_error(-20000,
            'Não foi possível criar uma nova tarefa: já há uma em execução.');
    END IF;

    DELETE FROM cs_active_job;
    INSERT INTO cs_active_job(job_id) VALUES (v_job_id);

    BEGIN
        INSERT INTO cs_jobs (job_id, start_stamp) VALUES (v_job_id, sysdate);
        -- não se preocupar se já existe
(4)

        EXCEPTION WHEN dup_val_on_index THEN NULL;
    END;
    COMMIT;
END;
/
show errors

Procedimentos como este podem ser facilmente convertidos em funções PostgreSQL que retornam um número inteiro. Em particular este procedimento é interessante, porque ensina algumas coisas:

Abaixo está mostrada uma maneira de como esta função poderia ser convertida para PL/pgSQL:

CREATE OR REPLACE FUNCTION cs_create_job(integer) RETURNS integer AS '
DECLARE
    v_job_id ALIAS FOR $1;
    a_running_job_count integer;
    a_num integer;
BEGIN
    LOCK TABLE cs_jobs IN EXCLUSIVE MODE;
    SELECT count(*)
    INTO a_running_job_count
    FROM cs_jobs
    WHERE end_stamp IS NULL;

    IF a_running_job_count > 0
    THEN
        RAISE EXCEPTION
            ''Não foi possível criar uma nova tarefa: já há uma em execução.'';
    END IF;

    DELETE FROM cs_active_job;
    INSERT INTO cs_active_job(job_id) VALUES (v_job_id);

    SELECT count(*) INTO a_num FROM cs_jobs WHERE job_id=v_job_id;
    IF NOT FOUND THEN  -- Se não foi retornado nada pela última consulta
        -- Esta tarefa não está na tabela então será inserida.
        INSERT INTO cs_jobs(job_id, start_stamp)
               VALUES (v_job_id, current_timestamp);
        RETURN 1;
    ELSE
        RAISE NOTICE ''Tarefa já em execução.'';
(1)

    END IF;

    RETURN 0;
END;
' LANGUAGE plpgsql;