43.13. 从OraclePL/SQL 移植#

43.13.1. 移植示例

43.13.2. 其他注意事项

43.13.3. 附录

本节介绍PostgreSQL的PL/pgSQL语言和 Oracle 的PL/SQL语言之间的差异，以帮助将应用程序从Oracle® 移植到PostgreSQL的开发者。

PL/pgSQL在许多方面与 PL/SQL 类似。它是一种块结构的命令式语言，所有变量都必须声明。赋值、循环和条件类似。从PL/SQL移植到PL/pgSQL时，您应该记住的主要差异是

• 如果在 SQL 命令中使用的名称既可能是命令中使用的表的列名称，也可能是函数变量的引用，PL/SQL 会将其视为列名称。默认情况下，PL/pgSQL 会抛出一个错误，抱怨该名称不明确。您可以指定 plpgsql.variable_conflict = use_column 以将此行为更改为匹配 PL/SQL，如 第 43.11.1 节 中所述。通常最好一开始就避免此类歧义，但如果您必须移植大量依赖此行为的代码，则设置 variable_conflict 可能是最佳解决方案。

• 在 PostgreSQL 中，函数体必须写为字符串文字。因此，您需要在函数体中使用美元引用或转义单引号。（请参阅 第 43.12.1 节。）

• 数据类型名称通常需要翻译。例如，在 Oracle 中，字符串值通常被声明为 varchar2 类型，这是一种非 SQL 标准类型。在 PostgreSQL 中，请改用 varchar 或 text 类型。类似地，将 number 类型替换为 numeric，或在有更合适的类型时使用其他一些数字数据类型。

• 使用模式将您的函数组织到组中，而不是使用包。

• 由于没有包，因此也没有包级变量。这有点烦人。您可以将每个会话的状态保存在临时表中。

• 带有 REVERSE 的整数 FOR 循环工作方式不同：PL/SQL 从第二个数字倒数到第一个数字，而 PL/pgSQL 从第一个数字倒数到第二个数字，需要在移植时交换循环边界。这种不兼容性很不幸，但不太可能改变。（请参阅 第 43.6.5.5 节。）

• 对查询（游标除外）的 FOR 循环的工作方式也不同：目标变量必须已经声明，而 PL/SQL 始终隐式声明它们。这样做的好处是，在循环退出后仍然可以访问变量值。

• 游标变量的使用存在各种符号差异。

43.13.1. 移植示例#

示例 43.9展示了如何将一个简单的函数从PL/SQL移植到PL/pgSQL。

示例 43.9. 将一个简单的函数从PL/SQL移植到PL/pgSQL

这是一个OraclePL/SQL函数

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

让我们浏览一下这个函数，看看与PL/pgSQL相比有哪些不同

• 类型名称 varchar2 必须更改为 varchar 或 text。在本节的示例中，我们将使用 varchar，但如果你不需要特定的字符串长度限制，text 通常是一个更好的选择。

• 函数原型（不是函数体）中的 RETURN 关键字在 PostgreSQL 中变为 RETURNS。此外，IS 变为 AS，并且你需要添加一个 LANGUAGE 子句，因为 PL/pgSQL 不是唯一可能的函数语言。

• 在 PostgreSQL 中，函数体被认为是一个字符串文字，因此你需要在函数体周围使用引号或美元符号引号。这代替了 Oracle 方法中的终止 /。

• show errors 命令在 PostgreSQL 中不存在，并且不需要，因为错误会自动报告。

以下是将此函数移植到PostgreSQL后的样子

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

示例 43.10展示了如何移植一个创建另一个函数的函数，以及如何处理随之而来的引用问题。

示例 43.10. 将一个创建另一个函数的函数从PL/SQL移植到PL/pgSQL

以下过程从SELECT语句中获取行，并在IF语句中使用结果构建一个大函数，以提高效率。

这是 Oracle 版本

CREATE OR REPLACE PROCEDURE cs_update_referrer_type_proc IS
    CURSOR referrer_keys IS
        SELECT * FROM cs_referrer_keys
        ORDER BY try_order;
    func_cmd VARCHAR(4000);
BEGIN
    func_cmd := 'CREATE OR REPLACE FUNCTION cs_find_referrer_type(v_host IN VARCHAR2,
                 v_domain IN VARCHAR2, v_url IN VARCHAR2) RETURN VARCHAR2 IS BEGIN';

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

    func_cmd := func_cmd || ' RETURN NULL; END;';

    EXECUTE IMMEDIATE func_cmd;
END;
/
show errors;

以下是该函数最终在PostgreSQL中的实现方式

CREATE OR REPLACE PROCEDURE cs_update_referrer_type_proc() AS $func$
DECLARE
    referrer_keys CURSOR IS
        SELECT * FROM cs_referrer_keys
        ORDER BY try_order;
    func_body text;
    func_cmd text;
BEGIN
    func_body := 'BEGIN';

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

    func_body := func_body || ' RETURN NULL; END;';

    func_cmd :=
      'CREATE OR REPLACE FUNCTION cs_find_referrer_type(v_host varchar,
                                                        v_domain varchar,
                                                        v_url varchar)
        RETURNS varchar AS '
      || quote_literal(func_body)
      || ' LANGUAGE plpgsql;' ;

    EXECUTE func_cmd;
END;
$func$ LANGUAGE plpgsql;

请注意，函数主体是单独构建的，并通过quote_literal传递，以便对其中的任何引号加倍。需要此技术，因为我们无法安全地使用美元引号来定义新函数：我们无法确切知道将从referrer_key.key_string字段内插哪些字符串。（我们在此假设始终可以信任referrer_key.kind为host、domain或url，但referrer_key.key_string可能为任何内容，特别是可能包含美元符号。）此函数实际上是对 Oracle 原始函数的改进，因为它不会在referrer_key.key_string或referrer_key.referrer_type包含引号时生成损坏的代码。

示例 43.11展示了如何移植带有OUT参数和字符串操作的函数。PostgreSQL没有内置的instr函数，但你可以使用其他函数的组合来创建它。在第 43.13.3 节中有一个PL/pgSQL实现的instr，你可以使用它来简化移植。

示例 43.11. 从PL/SQL移植包含字符串操作和OUT参数的过程到PL/pgSQL

以下OraclePL/SQL 过程用于解析 URL 并返回多个元素（主机、路径和查询）。

这是 Oracle 版本

CREATE OR REPLACE PROCEDURE cs_parse_url(
    v_url IN VARCHAR2,
    v_host OUT VARCHAR2,  -- This will be passed back
    v_path OUT VARCHAR2,  -- This one too
    v_query OUT VARCHAR2) -- And this one
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;

以下是可能的PL/pgSQL翻译

CREATE OR REPLACE FUNCTION cs_parse_url(
    v_url IN VARCHAR,
    v_host OUT VARCHAR,  -- This will be passed back
    v_path OUT VARCHAR,  -- This one too
    v_query OUT VARCHAR) -- And this one
AS $$
DECLARE
    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;
$$ LANGUAGE plpgsql;

此函数可如此使用

SELECT * FROM cs_parse_url('http://foobar.com/query.cgi?baz');

示例 43.12展示了如何移植使用 Oracle 特有众多功能的过程。

示例 43.12. 从PL/SQL移植过程到PL/pgSQL

Oracle 版本

CREATE OR REPLACE PROCEDURE cs_create_job(v_job_id IN INTEGER) IS
    a_running_job_count 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
        COMMIT; -- free lock
        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, now());
    EXCEPTION
        WHEN dup_val_on_index THEN NULL; -- don't worry if it already exists
    END;
    COMMIT;
END;
/
show errors

以下是我们可以将此过程移植到PL/pgSQL的方式

CREATE OR REPLACE PROCEDURE cs_create_job(v_job_id integer) AS $$
DECLARE
    a_running_job_count 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
        COMMIT; -- free lock
        RAISE EXCEPTION 'Unable to create a new job: a job is currently running'; -- (1)
    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, now());
    EXCEPTION
        WHEN unique_violation THEN -- (2)
            -- don't worry if it already exists
    END;
    COMMIT;
END;
$$ LANGUAGE plpgsql;

(1)	RAISE 语句的语法与 Oracle 语句有很大不同，尽管基本情况 RAISE exception_name 的工作方式类似。
(2)	PL/pgSQL 支持的异常名称与 Oracle 的不同。内置异常名称的集合更大（参见 附录 A）。目前没有办法声明用户定义的异常名称，但你可以抛出用户选择的 SQLSTATE 值。

43.13.2. 其他需要注意的事项#

本节说明在将 OraclePL/SQL函数移植到PostgreSQL时需要注意的其他一些事项。

43.13.2.1. 异常后隐式回滚#

在PL/pgSQL中，当异常被EXCEPTION子句捕获时，自块的BEGIN以来所有数据库更改都会自动回滚。也就是说，行为等同于你在 Oracle 中使用

BEGIN
    SAVEPOINT s1;
    ... code here ...
EXCEPTION
    WHEN ... THEN
        ROLLBACK TO s1;
        ... code here ...
    WHEN ... THEN
        ROLLBACK TO s1;
        ... code here ...
END;

如果你正在翻译一个使用SAVEPOINT和ROLLBACK TO的 Oracle 过程，你的任务很简单：省略SAVEPOINT和ROLLBACK TO。如果你有一个以不同方式使用SAVEPOINT和ROLLBACK TO的过程，那么需要进行一些实际思考。

43.13.2.2.EXECUTE#

PL/pgSQL版本的EXECUTE与PL/SQL版本类似，但你必须记住使用quote_literal和quote_ident，如第 43.5.4 节所述。除非你使用这些函数，否则EXECUTE 'SELECT * FROM $1';类型的构造将无法可靠地工作。

43.13.2.3. 优化PL/pgSQL函数#

PostgreSQL提供了两个函数创建修饰符来优化执行：“易失性”（当给定相同参数时函数是否始终返回相同结果）和“严格性”（如果任何参数为 null，函数是否返回 null）。有关详细信息，请参阅CREATE FUNCTION参考页面。

在使用这些优化属性时，您的CREATE FUNCTION语句可能如下所示

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

43.13.3. 附录#

本节包含一组 Oracle 兼容instr函数的代码，您可以使用这些函数简化移植工作。

--
-- instr functions that mimic Oracle's counterpart
-- Syntax: instr(string1, string2 [, n [, m]])
-- where [] denotes optional parameters.
--
-- Search string1, beginning at the nth character, for the mth occurrence
-- of string2.  If n is negative, search backwards, starting at the abs(n)'th
-- character from the end of string1.
-- If n is not passed, assume 1 (search starts at first character).
-- If m is not passed, assume 1 (find first occurrence).
-- Returns starting index of string2 in string1, or 0 if string2 is not found.
--

CREATE FUNCTION instr(varchar, varchar) RETURNS integer AS $$
BEGIN
    RETURN instr($1, $2, 1);
END;
$$ LANGUAGE plpgsql STRICT IMMUTABLE;


CREATE FUNCTION instr(string varchar, string_to_search_for varchar,
                      beg_index integer)
RETURNS integer AS $$
DECLARE
    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_for IN temp_str);

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

        WHILE beg > 0 LOOP
            temp_str := substring(string FROM beg FOR ss_length);
            IF string_to_search_for = temp_str THEN
                RETURN beg;
            END IF;

            beg := beg - 1;
        END LOOP;

        RETURN 0;
    ELSE
        RETURN 0;
    END IF;
END;
$$ LANGUAGE plpgsql STRICT IMMUTABLE;


CREATE FUNCTION instr(string varchar, string_to_search_for varchar,
                      beg_index integer, occur_index integer)
RETURNS integer AS $$
DECLARE
    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 occur_index <= 0 THEN
        RAISE 'argument ''%'' is out of range', occur_index
          USING ERRCODE = '22003';
    END IF;

    IF beg_index > 0 THEN
        beg := beg_index - 1;
        FOR i IN 1..occur_index LOOP
            temp_str := substring(string FROM beg + 1);
            pos := position(string_to_search_for IN temp_str);
            IF pos = 0 THEN
                RETURN 0;
            END IF;
            beg := beg + pos;
        END LOOP;

        RETURN beg;
    ELSIF beg_index < 0 THEN
        ss_length := char_length(string_to_search_for);
        length := char_length(string);
        beg := length + 1 + beg_index;

        WHILE beg > 0 LOOP
            temp_str := substring(string FROM beg FOR ss_length);
            IF string_to_search_for = temp_str 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;
    ELSE
        RETURN 0;
    END IF;
END;
$$ LANGUAGE plpgsql STRICT IMMUTABLE;