37.11. 从Oracle的 PL/SQL 移植

本节解释了Oracle的 PL/SQL 和PostgreSQLPL/pgSQL语言之间的差别, 希望能对那些从OraclePostgreSQL移植应用的人有所帮助。

PL/pgSQL与 PL/SQL 在许多方面都非常类似。 它是一种块结构的,祈使语气(命令性)的语言并且必须声明所有变量。 赋值,循环,条件等都很类似。 在从OraclePostgreSQL移植的时候必须记住一些事情:

37.11.1. 移植样例

Example 37-2 演示了如何从 PL/SQLPL/pgSQL 移植一个简单的函数。

Example 37-2. 从 PL/SQLPL/pgSQL 移植一个简单的函数

下面是一个Oracle PL/SQL函数:

CREATE OR REPLACE FUNCTION cs_fmt_browser_version(v_name IN varchar, v_version IN varchar)
RETURN varchar IS
BEGIN
    IF v_version IS NULL THEN
        RETURN v_name;
    END IF;
    RETURN v_name || '/' || v_version;
END;
/
SHOW errors;

让我们读一遍这个函数然后看看PL/pgSQL与之的不同:

  • PostgreSQL 没有命名的参数。 你必须在自己的函数中明确地给它们取个别名。

  • Oracle可以有 INOUT, 和 INOUT 参数传递给函数。比如, INOUT 的意思是该参数将接受一个数值并且返回另外一个。 PostgreSQL只有 "IN" 参数。

  • 在函数原型里的 RETURN (不是函数体里的)关键字到了 PostgreSQL 里就是 RETURNS

  • PostgreSQL里,函数是使用单引号做为分隔符创建的, 因此你必须在你的函数体里逃逸单引号。

  • PostgreSQL里没有 /show errors 命令。

下面是这个函数移植到PostgreSQL之后的样子:

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

Example 37-3 演示了如何移植一个创建另外一个函数的函数的方法,以及演示了如何处理逃逸引号的问题。

Example 37-3. 从PL/SQLPL/pgSQL 移植一个创建其它函数的函数

下面的过程从一个 SELECT 语句中抓取若干行, 然后为了提高效率,又用 IF 语句中的结果制作了一个巨大的函数。 请特别注意在游标和 FOR 循环里面的不同。

这是 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;

下面是这个函数在 PostgreSQL 里面的样子:

CREATE FUNCTION cs_update_referrer_type_proc() RETURNS integer AS '
DECLARE
    referrer_keys RECORD;  -- 声明一个在 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 ''; 

    -- 请注意我们是如何在一个 FOR 循环中使用 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 的原因是因为我们没有代换任何变量
    -- 否则它可就不能玩了。请查阅 PERFORM 获取另外一种运行函数的方法
    
    EXECUTE a_output; 
END; 
' LANGUAGE plpgsql;

Example 37-4 演示了如何移植一个带有 OUT 参数和字串处理的函数。PostgreSQL 里面没有 instr 函数,但是你可以用其它函数的组合来绕开它。 在 Section 37.11.3 里有一个 PL/pgSQLinstr 实现, 你可以用它让你的移植变得更简单些。

Example 37-4. 从 PL/SQLPL/pgSQL 移植一个字串操作和OUT参数的过程

下面的OraclePL/SQL 过程用于分析一个 URL 并且返回若干个元素 (主机,路径和命令)。PL/pgSQL函数只能返回一个数值。 在 PostgreSQL里,一个绕开这个局限的方法就是把过程分裂成三个不同的函数: 一个返回主机,另外一个返回路径,最后一个返回命令。

下面是 Oracle 的版本:

CREATE OR REPLACE PROCEDURE cs_parse_url(
    v_url IN varchar,
    v_host OUT varchar,  -- 这个变量是要传回的
    v_path OUT varchar,  -- 这个也是
    v_query OUT varchar) -- 还有这个
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;

下面就是把这个过程翻译成PostgreSQL的样子:

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 '''';  -- 返回一个空
    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;

Example 37-5 演示了如何一个使用各种 Oracle 特有的特性的过程。

Example 37-5. 从 PL/SQLPL/pgSQL 移植一个过程

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; -- free lock(3)
        raise_application_error(-20000, 'Unable to create a new job: a job IS currently running.');
    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);
        EXCEPTION WHEN dup_val_on_index THEN NULL; -- don't worry IF it already exists(4)
    END;
    COMMIT;
END;
/
show errors

象这样的过程可以很容易用返回 integer 的 函数移植到PostgreSQL里.我们对这个过程特别感兴趣是因为它可以教我们一些东西:

(1)
PostgreSQL里没有 PRAGMA 语句。
(2)
如果你在PL/pgSQL里做一个 LOCK TABLE, 那么这个锁在调用该命令的事务完成之前将不会释放。
(3)
你也不能在PL/pgSQL过程里使用事务。 整个函数(以及其它从那里面调用的函数)都是在一个事务里执行的并且如果出错了,那么 PostgreSQL将回滚结果。
(4)
EXCEPTION WHEN 不得不用一个 IF 语句替代.

下面是我们把这个过程移植到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 ''Unable to create a new job: a job IS currently running.'';
    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  -- If nothing wAS RETURNed in the last query
        -- 该作业不在该表中,因此让我们把它插入
        INSERT INTO cs_jobs(job_id, start_stamp) values(v_job_id, current_timestamp);
        RETURN 1;
    ELSE
        RAISE NOTICE ''Job already running.'';(1)
    END IF;

    RETURN 0;
END;
' LANGUAGE plpgsql;

(1)
请注意你在PL/pgSQL 里抛出注意信息(或者错误)的方法。

37.11.2. 其它要注意的东西

本节解释几个从 Oracle PL/SQL 函数向 PostgreSQL 移植的几个其它方面的事情。

37.11.2.1. EXECUTE

PostgreSQL版本的 EXECUTE 运转得类似 PL/SQL 的, 不果你必须记住要象 Section 37.6.4 里描述的那样用 quote_literal(text)quote_string(text)。 如果你不用这些函数,那么象 EXECUTE ''SELECT * FROM $1''; 这样的构造是不会运转的。

37.11.2.2. 优化PL/pgSQL函数

PostgreSQL给你两个创建函数的修饰词用来优化执行: "易变的"(在给出的参数相同时, 函数总是返回相同结果)和 严格的(如果任何参数是 NULL,那么函数返回 NULL)。 参考 CREATE FUNCTION 的手册获取细节。

如果要使用这些优化属性,那么你的 CREATE FUNCTION 语句可能看起来像这样:

CREATE FUNCTION foo(...) RETURNS integer AS '
...
' LANGUAGE plpgsql STRICT IMMUTABLE;

37.11.3. 附录

本节包含 Oracle-兼容的 instr,你可以用它简化你的移植过程。

--
-- 模拟 Oracle 概念的 instr 函数
-- 语法: instr(string1,string2,[n],[m]) 这里的 [] 表示可选参数
-- 
-- 从 string1 的第 n 个字符开始寻找 string2 的第 m 个出现。
-- 如果 n 是负数,则从后向前着。如果没有传递 m,假定胃 1(从第一个字符开始找)。
-- 
--

CREATE OR REPLACE FUNCTION instr(varchar,varchar) RETURNS integer AS '
DECLARE
    pos integer;
BEGIN
    pos:= instr($1, $2, 1);
    RETURN pos;
END;
' LANGUAGE plpgsql;


CREATE OR REPLACE FUNCTION instr(varchar, varchar, integer) RETURNS integer AS '
DECLARE
    string ALIAS FOR $1;
    string_to_search ALIAS FOR $2;
    beg_index ALIAS FOR $3;
    pos integer NOT NULL DEFAULT 0;
    temp_str varchar;
    beg integer;
    length integer;
    ss_length integer;
BEGIN
    IF beg_index > 0 THEN

       temp_str := substring(string FROM beg_index);
       pos := position(string_to_search IN temp_str);

       IF pos = 0 THEN
	         RETURN 0;
	     ELSE
	         RETURN pos + beg_index - 1;
	     END IF;
    ELSE
       ss_length := char_length(string_to_search);
       length := char_length(string);
       beg := length + beg_index - ss_length + 2;

       WHILE beg > 0 LOOP

           temp_str := substring(string FROM beg FOR ss_length);
	         pos := position(string_to_search IN temp_str);

	         IF pos > 0 THEN
		           RETURN beg;
	         END IF;

	         beg := beg - 1;
       END LOOP;

       RETURN 0;
    END IF;
END;
' LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION instr(varchar,varchar,integer,integer) RETURNS integer AS '
DECLARE
    string ALIAS FOR $1;
    string_to_search ALIAS FOR $2;
    beg_index ALIAS FOR $3;
    occur_index ALIAS FOR $4;
    pos integer NOT NULL DEFAULT 0;
    occur_number integer NOT NULL DEFAULT 0;
    temp_str varchar;
    beg integer;
    i integer;
    length integer;
    ss_length integer;
BEGIN
    IF beg_index > 0 THEN
        beg := beg_index;
        temp_str := substring(string FROM beg_index);

        FOR i IN 1..occur_index LOOP
            pos := position(string_to_search IN temp_str);

            IF i = 1 THEN
                beg := beg + pos - 1;
            ELSE
                beg := beg + pos;
            END IF;

            temp_str := substring(string FROM beg + 1);
        END LOOP;

        IF pos = 0 THEN
            RETURN 0;
        ELSE
            RETURN beg;
        END IF;
    ELSE
        ss_length := char_length(string_to_search);
        length := char_length(string);
        beg := length + beg_index - ss_length + 2;

        WHILE beg > 0 LOOP
            temp_str := substring(string FROM beg FOR ss_length);
            pos := position(string_to_search IN temp_str);

            IF pos > 0 THEN
                occur_number := occur_number + 1;

                IF occur_number = occur_index THEN
                    RETURN beg;
                END IF;
            END IF;

            beg := beg - 1;
        END LOOP;

        RETURN 0;
    END IF;
END;
' LANGUAGE plpgsql;