↑↓ 选择 ↵ 打开 ⌫ 改范围 完整检索页

pgsql.cc 提供对 postgresql.org 官网内容的中文翻译,由 Pigsty 团队维护。

受支持版本: 当前版本 (18) / 17 / 16 / 15 / 14
测试与开发版本: 19 / devel
不受支持的版本: 13 / 12 / 11 / 10 / 9.6 / 9.5 / 9.4 / 9.3 / 9.2 / 9.1 / 9.0 / 8.4 / 8.3 / 8.2 / 8.1 / 8.0 / 7.4 / 7.3 / 7.2 / 7.1
历史版本PostgreSQL 7.1 已于 2006 年 4 月结束社区维护,本页译文保留供仍在使用旧版本的读者参考。新系统请看当前版本。

24.5. 从 Oracle PL/SQL 移植 #

Roberto Mello

      
     

作者

Roberto Mello()

本节解释 Oracle 的 PL/SQL 与 PostgreSQL 的 PL/pgSQL 语言之间的 差异,希望能帮助开发者把应用从 Oracle 移植到 PostgreSQL。这里 的多数代码来自ArsDigita 的Clickstream 模块,那是我在 2000 年夏到 OpenForce Inc.实习时 移植到 PostgreSQL 的。

PL/pgSQL 在许多方面与 PL/SQL 相似。它是一种块结构的命令式语言 (所有变量都必须声明)。PL/SQL 比它在 PostgreSQL 中的对应物 拥有多得多的特性,但 PL/pgSQL 提供了大量的功能,而且它在不断 改进。

24.5.1. 主要差异

从 Oracle 移植到 PostgreSQL 时应当记住的一些事情:

  • PostgreSQL 没有默认参数。

  • 在 PostgreSQL 中可以重载函数。这常被用来变通解决缺少默认 参数的问题。

  • 赋值、循环和条件语句是相似的。

  • PostgreSQL 中不需要游标,只要把查询放进 FOR 语句即可 (见下面的例子)

  • 在 PostgreSQL 中你需要转义单引号。 参见第 24.5.1.1 节。

24.5.1.1. 转义单引号 #

在 PostgreSQL 中,你需要转义函数定义内部的单引号。这有时会 导致相当有趣的代码,尤其是当你在创建一个会生成其他函数的 函数时,就像例 24.6中那样。 在转义大量单引号时要记住的一点是:除开头/结尾的引号外, 其余引号都会成对出现。

表 24.1给出了全部诀窍。(你会爱上 这张小表的。)

表 24.1. 单引号转义表

引号数 用途 示例 结果
1 开始/结束函数体
CREATE FUNCTION foo() RETURNS INTEGER AS '...'
LANGUAGE 'plpgsql';
原样
2 在赋值、SELECT 中定界字符串等
a_output := ''Blah'';
SELECT * FROM users WHERE f_name=''foobar'';
SELECT * FROM users WHERE f_name='foobar';
4 当你需要在结果字符串中出现两个单引号而又不终止该字符串 时。
a_output := a_output || '' AND name 
    LIKE ''''foobar'''' AND ...''
AND name LIKE 'foobar' AND ...
6 当你想在结果字符串中出现两个单引号并且 终止该字符串时。
a_output := a_output || '' AND name 
    LIKE ''''foobar''''''
AND name LIKE 'foobar'
10 当你想在结果字符串中出现两个单引号(这需要 8 个引号) 并且终止该字符串(再需要 2 个)时。 只有在你用一个函数生成其他函数时才可能需要这样做 (就像例 24.6中那样)。
a_output := a_output || '' if v_'' || 
    referrer_keys.kind || '' like '''''''''' 
    || referrer_keys.key_string || '''''''''' 
    then return ''''''  || referrer_keys.referrer_type 
    || ''''''; end if;''; 
if v_<...> like ''<...>'' then return ''<...>''; end if;

24.5.2.  移植函数 #

例 24.5.  一个简单的函数

下面是一个 Oracle 函数:

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 的差异:

  • 不允许使用 OR REPLACE 子句。要达到类似 的效果,你必须在创建函数之前显式地删除它。

  • PostgreSQL没有命名参数。你必须在 函数内部显式地为它们声明别名。

  • Oracle 的函数可以有IN、OUT 和INOUT参数。例如INOUT 意味着该参数接收一个值并返回另一个值。PostgreSQL 只有 “IN”参数,而且函数只能返回单个值。

  • 函数原型(而非函数体)中的RETURN关键字 在 PostgreSQL 中变成RETURNS。

  • 在 PostgreSQL 中,创建函数使用单引号作为定界符,因此你 必须转义函数内部的单引号(这有时会相当令人厌烦;参见 第 24.5.1.1 节)。

  • /show errors命令在 PostgreSQL 中不存在。

那么让我们看看这个函数移植到 PostgreSQL 之后是什么样子:

DROP FUNCTION cs_fmt_browser_version(varchar, varchar);
CREATE FUNCTION cs_fmt_browser_version(varchar, varchar)
RETRUNS 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';

例 24.6.  一个创建另一个函数的函数

下面的过程从一条SELECT语句抓取行,并为了 效率把结果构建成带IF语句的一个大函数。 请特别注意游标、FOR循环的差异,以及在 PostgreSQL 中转义单引号的必要性。

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;  -- Declare a generic record to be used in a 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; ''; 

    -- 
    -- Notice how we scan through the results of a query in a FOR loop
    -- using the FOR <record> construct.
    --

    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'''';''; 
 
    -- This works because we are not substituting any variables
    -- Otherwise it would fail. Look at PERFORM for another way to run functions
    
    EXECUTE a_output; 
end; 
' LANGUAGE 'plpgsql';

例 24.7.  一个带大量字符串操作和 OUT 参数的过程

下面的 Oracle PL/SQL 过程用于解析 URL 并返回若干元素(主机、 路径和查询)。它是一个过程,因为在 PL/pgSQL 中函数只能返回 一个值(参见第 24.5.3 节)。在 PostgreSQL 中,绕开这个问题的一种办法是把该过程拆成三个不同 的函数:一个返回主机,一个返回路径,另一个返回查询。

create or replace procedure 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
is
    a_pos1 integer;
    a_pos2 integer;
begin
    v_host := NULL;
    v_path := NULL;
    v_query := NULL;
    a_pos1 := instr(v_url, '//'); -- PostgreSQL doesn't have an instr function

    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 改写:

drop function cs_parse_url_host(varchar); 
create 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 '''';  -- Return a blank
    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';

注意

PostgreSQL 没有instr函数,因此你可以用 其他函数的组合来变通。我厌倦了这样做,于是创建了自己的 instr函数,其行为与 Oracle 的完全一致 (这让生活更轻松)。代码见 第 24.5.6 节。

24.5.3.  过程 #

Oracle 的过程给开发者多了一点灵活性,因为不需要显式返回 任何东西,但也可以通过 INOUT 或 OUT 参数返回。

一个例子:

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 会回滚结果。因此只允许一个BEGIN语句。

(4)

exception when 必须被替换成一个IF语句。

那么让我们看看把这个过程移植到 PL/pgSQL 的一种做法:

drop function cs_create_job(integer);
create function cs_create_job(integer) returns integer as ' declare
    v_job_id alias for $1;
    a_running_job_count integer;
    a_num integer;
    -- pragma autonomous_transaction;
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.'';
    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
        -- This job is not in the table so lets insert it.
        insert into cs_jobs(job_id, start_stamp) values(v_job_id, sysdate());
        return 1;
    ELSE
        raise NOTICE ''Job already running.'';(1)
    END IF;

    return 0;
end;
' language 'plpgsql';

(1)

Notice how you can raise notices (or errors) in PL/pgSQL.

24.5.4.  包 #

注意

我自己没有怎么用过包,所以如果这里有错误,请告诉我。

包是 Oracle 提供的一种把 PL/SQL 语句和函数封装到一个实体中的 手段,就像 Java 的类一样,你在其中定义方法和对象。你可以用 “.”(点号)访问这些对象/方法。 下面是 ACS 4(ArsDigita Community System)中一个 Oracle 包的例子:

create or replace package body acs
as
  function add_user (
    user_id     in users.user_id%TYPE default null,
    object_type     in acs_objects.object_type%TYPE
               default 'user',
    creation_date   in acs_objects.creation_date%TYPE
               default sysdate,
    creation_user   in acs_objects.creation_user%TYPE
               default null,
    creation_ip     in acs_objects.creation_ip%TYPE default null,
  ...
  ) return users.user_id%TYPE
  is
    v_user_id       users.user_id%TYPE;
    v_rel_id        membership_rels.rel_id%TYPE;
  begin
    v_user_id := acs_user.new (user_id, object_type, creation_date,
                creation_user, creation_ip, email,
    ...
    return v_user_id;
  end;
end acs;
/
show errors

我们把 Oracle 包的各个对象以标准命名约定创建为函数,从而把它 移植到 PostgreSQL。我们还必须注意其他一些细节,比如 PostgreSQL 函数缺少默认参数。上面的包会变成类似这样:

CREATE FUNCTION acs__add_user(integer,integer,varchar,datetime,integer,integer,...)
RETURNS integer AS '
DECLARE
    user_id ALIAS FOR $1;
    object_type ALIAS FOR $2;
    creation_date ALIAS FOR $3;
    creation_user ALIAS FOR $4;
    creation_ip ALIAS FOR $5;
    ...
    v_user_id users.user_id%TYPE;
    v_rel_id membership_rels.rel_id%TYPE;
BEGIN
    v_user_id := acs_user__new(user_id,object_type,creation_date,creation_user,creation_ip, ...);
    ...

    return v_user_id;
END;
' LANGUAGE 'plpgsql';

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

24.5.5.1. EXECUTE

PostgreSQL 版本的EXECUTE工作得很好,但你 必须记住按照 第 24.2.5.3 节中的说明 使用quote_literal(TEXT)和 quote_string(TEXT)。像 EXECUTE ''SELECT * from $1'';这类构造如果 不使用这些函数就无法工作。

24.5.5.2. 优化 PL/pgSQL 函数 #

PostgreSQL 提供了两个函数创建修饰符来优化执行: iscachable(给定相同参数时函数总是返回相同 结果)和isstrict(任一参数为 NULL 时函数 返回 NULL)。细节请查阅CREATE FUNCTION参考。

要使用这些优化属性,你必须在CREATE FUNCTION语句中使用WITH修饰符。 类似这样:

CREATE FUNCTION foo(...) RETURNS integer AS '
...
' LANGUAGE 'plpgsql'
WITH (isstrict, iscachable);

24.5.6.  附录 #

24.5.6.1.  我的instr函数的代码

--
-- instr functions that mimic Oracle's counterpart
-- Syntax: instr(string1,string2,[n],[m]) where [] denotes optional params.
-- 
-- Searches string1 beginning at the nth character for the mth
-- occurrence of string2. If n is negative, search backwards. If m is
-- not passed, assume 1 (search starts at first character).
--
-- by Roberto Mello (rmello@fslc.usu.edu)
-- modified by Robert Gaszewski (graszew@poland.com)
-- Licensed under the GPL v2 or later.
--

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


DROP FUNCTION instr(varchar,varchar,integer);
CREATE 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';

--
-- Written by Robert Gaszewski (graszew@poland.com)
-- Licensed under the GPL v2 or later.
--
DROP FUNCTION instr(varchar,varchar,integer,integer);
CREATE 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';

提交更正

译文有误、术语不当或页面显示问题,请到译文仓库 pgsty/pgdoc 报告译文问题。 英文原文本身的问题,请在当前版本的对应页面向上游反馈;上游不再修订已结束维护的版本。