35.11. 從Oracle的 PL/SQL 移植

本節解釋了OraclePL/SQLPostgreSQLPL/pgSQL語言之間的差別, 希望能對那些從Oracle®向PostgreSQL移植應用的人有所幫助。

PL/pgSQL與 PL/SQL 在許多方面都非常類似。 它是一種塊結構的,祈使語氣(命令性)的語言並且必須聲明所有變量。 賦值,循環,條件等都很類似。 在從OraclePostgreSQL移植的時候必須記住一些事情:

35.11.1. 移植樣例

Example 35-4 演示了如何從 PL/SQLPL/pgSQL 移植一個簡單的函數。

Example 35-4. 從 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與之的不同:

  • Oracle可以有 INOUT, 和 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 演示了如何移植一個建立另外一個函數的函數的方法,以及演示了如何處理引號逃逸的問題。

Example 35-5. 從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;

    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 可以是只有 hostdomain,或者 url,但是 referrer_key.key_string 可能是任何東西, 特別是它可能包含美元符。)這個函數實際上是對原來 Oracle 版本的一個改進, 因為如果在 referrer_key.key_string 或者 referrer_key.referrer_type 包含單引號的時候, 它不會生成有毛病的代碼。

Example 35-6 演示了如何移植一個帶有 OUT 參數和字串處理的函數。PostgreSQL 裡面沒有 instr 函數,但是您可以用其它函數的組合來繞開它。 在 Section 35.11.3 裡有一個 PL/pgSQLinstr 實現, 您可以用它讓您的移植變得更簡單些。

Example 35-6. 從 PL/SQLPL/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 演示了如何一個使用各種 Oracle 特有的特性的過程。

Example 35-7. 從 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; -- 如果已經存在,別擔心
    END;
    COMMIT;
END;
/
show errors

像這樣的過程可以很容易用返回 void 的函數移植到PostgreSQL裡。 我們對這個過程特別感興趣是因為它可以教我們一些東西:

(1)
PostgreSQL裡沒有 PRAGMA 語句。
(2)
如果您在PL/pgSQL裡做一個 LOCK TABLE, 那麼這個鎖在調用該命令的交易完成之前將不會釋放。
(3)
您不能在 PL/pgSQL 函數里發出 COMMIT。 函數是在外層的交易裡執行的,因此 COMMIT 蘊涵著結束函數的執行。 不過,在這個特殊場合下,這是不必要的了,因為 LOCK TABLE 獲取的鎖將在我們拋出錯誤的時候釋放。
(2)
EXCEPTION WHEN 不得不用一個 IF 語句替代.

下面是我們把這個過程移植到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;

(1)
RAISE 的語法和 Oracle 的類似語句差別相當明顯。
(2)
PL/pgSQL 裡支援的例外的名字和 Oracle 的不同。 PL/pgSQL 內置的例外名要大的多(參閱 Appendix A)。 目前還不能聲明用戶定義的例外名。
整個過程和 Oracle 的等效的主要的功能型差別是,在 cs_jobs 上持有的排他鎖將保持到調用的交易結束。 同樣,如果調用者後來退出(比如說因為錯誤),這個過程的效果將被回滾掉。

35.11.2. 其它要注意的東西

本節解釋幾個從 Oracle PL/SQL 函數向 PostgreSQL 移植的幾個其它方面的事情。

35.11.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;

如果您在把這麼使用 SAVEPOINTROLLBACK TO 的 Oracle 過程翻譯過來,那麼您的活兒很好干:只要省略 SAVEPOINTROLLBACK TO 即可。 如果您要翻譯的過程使用了不同的 SAVEPOINTROLLBACK TO,那麼就需要想想了。

35.11.2.2. EXECUTE

PostgreSQL版本的 EXECUTE 運轉得類似 PL/SQL 的, 不果您必須記住要象 Section 35.6.4 裡描述的那樣用 quote_literal(text)quote_string(text)。 如果您不用這些函數,那麼象 EXECUTE 'SELECT * FROM $1'; 這樣的構造是不會運轉的。

35.11.2.3. 優化PL/pgSQL函數

PostgreSQL給您兩個建立函數的修飾詞用來優化執行: "volatility(易變的)"(在給出的參數相同時, 函數總是返回相同結果)和 strictness(嚴格的)(如果任何參數是 NULL,那麼函數返回 NULL)。 參考 CREATE FUNCTION 的手冊獲取細節。

如果要使用這些優化屬性,那麼您的 CREATE FUNCTION 語句可能看起來像這樣:

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

35.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 STRICT IMMUTABLE;


CREATE FUNCTION instr(string varchar, string_to_search varchar, beg_index integer)
RETURNS integer AS $$
    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 STRICT IMMUTABLE;

CREATE FUNCTION instr(string varchar, string_to_search varchar,
                      beg_index integer, occur_index 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  STRICT IMMUTABLE;