35.11. 从Oracle的 PL/SQL 移植

Example 35-4. 从 PL/SQL 向 PL/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与之的不同：

• Oracle可以有 IN，OUT， 和 INOUT 参数传递给函数。比如， INOUT 的意思是该参数将接受一个数值并且返回另外一个。 PostgreSQL只有 "IN" 参数，因此没有这样的参数类型的声明。

• 在函数原型里的 RETURN （不是函数体里的）关键字到了 PostgreSQL 里就是 RETURNS。还有，IS 变成 AS， 并且你还需要增加一个 LANGUAGE 子句，因为 PL/pgSQL 并非唯一可用的函数语言。

• 在PostgreSQL里，函数体被认为是一个字串文本， 所以你需要使用单引号或者美元符包围它，这个包围符代替了Oracle最后的那个 /。

• 在PostgreSQL里没有 show errors 命令，不需要这个命令是因为错误是自动报告的。

下面是这个函数移植到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;

Example 35-5. 从PL/SQL 向 PL/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;

    func_cmd varchar(4000); 
BEGIN 
    func_cmd := '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 
        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 FUNCTION cs_update_referrer_type_proc() RETURNS void AS $func$
DECLARE
    referrer_key RECORD;  -- 声明一个在 FOR 里用的通用的记录
    func_body text;
    func_cmd text;
BEGIN 
    func_body := 'BEGIN' ;

    -- 请注意我们是如何在一个 FOR 循环中使用 FOR <record> 构造
    -- 扫描各条结果的

    FOR referrer_key IN SELECT * FROM cs_referrer_keys ORDER BY try_order 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;
    RETURN;
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 包含单引号的时候， 它不会生成有毛病的代码。

Example 35-6. 从 PL/SQL 向 PL/pgSQL 移植一个字串操作和OUT参数的过程

下面的OraclePL/SQL 过程用于分析一个 URL 并且返回若干个元素 （主机，路径和命令）。PL/pgSQL函数只能返回一个数值。 一个绕开这个局限的方法是把返回值做成复合类型（行类型）。

下面是 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 TYPE cs_parse_url_result AS (
    v_host VARCHAR,
    v_path VARCHAR,
    v_query VARCHAR
);

CREATE OR REPLACE FUNCTION cs_parse_url(v_url VARCHAR)
RETURNS cs_parse_url_result AS $$
DECLARE
    res cs_parse_url_result;
    a_pos1 INTEGER;
    a_pos2 INTEGER;
BEGIN
    res.v_host := NULL;
    res.v_path := NULL;
    res.v_query := NULL;
    a_pos1 := instr(v_url, '//');

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

    res.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
        res.v_path := substr(v_url, a_pos2);
        RETURN res;
    END IF;

    res.v_path := substr(v_url, a_pos2, a_pos1 - a_pos2);
    res.v_query := substr(v_url, a_pos1 + 1);
    RETURN res;
END;
$$ LANGUAGE plpgsql;

这个函数可以这么用：

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

Example 35-7. 从 PL/SQL 向 PL/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; -- 如果已经存在，别担心
    END;
    COMMIT;
END;
/
show errors

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

下面是我们把这个过程移植到PL/pgSQL里的一种方法：

CREATE OR REPLACE FUNCTION cs_create_job(v_job_id integer) RETURNS void 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
        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;

    RETURN;
END;
$$ LANGUAGE plpgsql;