Received: from maia.hub.org (unknown [200.46.208.211]) by mail.postgresql.org (Postfix) with ESMTP id 64F37633515 for ; Fri, 23 Apr 2010 23:31:29 -0300 (ADT) Received: from mail.postgresql.org ([200.46.204.86]) by maia.hub.org (mx1.hub.org [200.46.208.211]) (amavisd-maia, port 10024) with ESMTP id 53017-03 for ; Sat, 24 Apr 2010 02:31:09 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.7.6 Received: from mail-qy0-f196.google.com (mail-qy0-f196.google.com [209.85.221.196]) by mail.postgresql.org (Postfix) with ESMTP id 553A56334AA for ; Fri, 23 Apr 2010 23:31:18 -0300 (ADT) Received: by qyk34 with SMTP id 34so6214756qyk.10 for ; Fri, 23 Apr 2010 19:31:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=gamma; h=domainkey-signature:mime-version:received:sender:received :in-reply-to:references:date:x-google-sender-auth:message-id:subject :from:to:content-type; bh=Y38E00CrE5LcE9LrZKEvyOBfdN/mrcvsfCU3pLVhT8A=; b=aXsfP03BZNRmXRcreVC5lbRamKdFU3CqYJpLZVwvkLcFsCUISaw2CyVaHW/hQMJa0U 00tszBj0yE036+02S5jF3AODE7IpyEawrQE7gYnd7oOlbjhS0MUPESgK1lqoorbi5WOW Rv4tTP6PT4VvaXWmf6rwkMHTHdGNISxb4X5H8= DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=gamma; h=mime-version:sender:in-reply-to:references:date :x-google-sender-auth:message-id:subject:from:to:content-type; b=shuF7JEcEe9wma9u1eBaBNO79j5OJ/LxOvWSxfHq1ifWFEukZ4KxGVUGuXxumpVIxp +H2YISTZZk48+djSSRPrZ/exaOrk+BKl3E9AgISKKhv1NK3RUz7usvcWFeehRlYKXkbr ZPydT3xV93UlTMExs7wAo9kosq6sdngimfVww= MIME-Version: 1.0 Received: by 10.229.184.130 with SMTP id ck2mr1033640qcb.95.1272076276844; Fri, 23 Apr 2010 19:31:16 -0700 (PDT) Received: by 10.229.37.65 with HTTP; Fri, 23 Apr 2010 19:31:16 -0700 (PDT) In-Reply-To: References: Date: Fri, 23 Apr 2010 22:31:16 -0400 X-Google-Sender-Auth: fb89b22babba8220 Message-ID: Subject: Re: Replacing Cursors with Temporary Tables From: Eliot Gable To: pgsql-performance@postgresql.org Content-Type: multipart/alternative; boundary=0016362848c29bc7d60484f2561b X-Virus-Scanned: Maia Mailguard 1.0.1 X-Spam-Status: No, hits=0.667 tagged_above=-10 required=5 tests=AWL=-0.134, BAYES_50=0.8, HTML_MESSAGE=0.001 X-Spam-Level: X-Archive-Number: 201004/309 X-Sequence-Number: 38559 --0016362848c29bc7d60484f2561b Content-Type: text/plain; charset=ISO-8859-1 More benchmarking results are in with a comparison between cursors, arrays, and temporary tables for storing, using, and accessing data outside the stored procedure: CREATE OR REPLACE FUNCTION Test_Init() RETURNS INTEGER AS $BODY$ DECLARE temp INTEGER; BEGIN DROP TABLE IF EXISTS test_table1 CASCADE; CREATE TABLE test_table1 ( id SERIAL NOT NULL PRIMARY KEY, junk_field1 INTEGER, junk_field2 INTEGER, junk_field3 INTEGER ) WITH (OIDS=FALSE); DROP INDEX IF EXISTS test_table1_junk_field1_idx CASCADE; DROP INDEX IF EXISTS test_table1_junk_field2_idx CASCADE; DROP INDEX IF EXISTS test_table1_junk_field3_idx CASCADE; FOR i IN 1..10000 LOOP INSERT INTO test_table1 (junk_field1, junk_field2, junk_field3) VALUES (i%10, i%20, i%30); END LOOP; CREATE INDEX test_table1_junk_field1_idx ON test_table1 USING btree (junk_field1); CREATE INDEX test_table1_junk_field2_idx ON test_table1 USING btree (junk_field2); CREATE INDEX test_table1_junk_field3_idx ON test_table1 USING btree (junk_field3); DROP TABLE IF EXISTS test_table2 CASCADE; CREATE TABLE test_table2 ( id SERIAL NOT NULL PRIMARY KEY, junk_field1 INTEGER, junk_field2 INTEGER, junk_field3 INTEGER ) WITH (OIDS=FALSE); DROP INDEX IF EXISTS test_table2_junk_field1_idx CASCADE; DROP INDEX IF EXISTS test_table2_junk_field2_idx CASCADE; DROP INDEX IF EXISTS test_table2_junk_field3_idx CASCADE; FOR i IN 1..10000 LOOP INSERT INTO test_table2 (junk_field1, junk_field2, junk_field3) VALUES (i%15, i%25, i%35); END LOOP; CREATE INDEX test_table2_junk_field1_idx ON test_table2 USING btree (junk_field1); CREATE INDEX test_table2_junk_field2_idx ON test_table2 USING btree (junk_field2); CREATE INDEX test_table2_junk_field3_idx ON test_table2 USING btree (junk_field3); RETURN 1; END; $BODY$ LANGUAGE plpgsql; SELECT * FROM Test_Init(); DROP TYPE IF EXISTS test_row_type CASCADE; CREATE TYPE test_row_type AS ( junk_field1 INTEGER, junk_field2 INTEGER, junk_field3 INTEGER ); CREATE OR REPLACE FUNCTION Test1() RETURNS INTEGER AS $BODY$ DECLARE temp_row test_row_type; cursresults test_row_type[]; curs SCROLL CURSOR IS SELECT * FROM test_table1 WHERE junk_field1=8; BEGIN FOR temp IN curs LOOP temp_row := temp; cursresults := array_append(cursresults, temp_row); END LOOP; OPEN curs; RETURN 1; END; $BODY$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION Test2() RETURNS INTEGER AS $BODY$ DECLARE cursresults test_row_type[]; cur SCROLL CURSOR IS SELECT * FROM unnest(cursresults); BEGIN cursresults := array(SELECT (junk_field1, junk_field2, junk_field3)::test_row_type AS rec FROM test_table1 WHERE junk_field1=8); OPEN cur; RETURN 1; END; $BODY$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION Test3() RETURNS INTEGER AS $BODY$ DECLARE BEGIN CREATE TEMPORARY TABLE results WITH (OIDS=FALSE) ON COMMIT DROP AS ( SELECT junk_field1, junk_field2, junk_field3 FROM test_table1 WHERE junk_field1=8 ); RETURN 1; END; $BODY$ LANGUAGE plpgsql; CREATE OR REPLACE FUNCTION Test4() RETURNS INTEGER AS $BODY$ DECLARE cur SCROLL CURSOR IS SELECT * FROM results; BEGIN CREATE TEMPORARY TABLE results WITH (OIDS=FALSE) ON COMMIT DROP AS ( SELECT junk_field1, junk_field2, junk_field3 FROM test_table1 WHERE junk_field1=8 ); OPEN cur; RETURN 1; END; $BODY$ LANGUAGE plpgsql; EXPLAIN ANALYZE SELECT * FROM Test1(); "Function Scan on test1 (cost=0.00..0.26 rows=1 width=4) (actual time=17.701..17.701 rows=1 loops=1)" "Total runtime: 17.714 ms" -- Ouch EXPLAIN ANALYZE SELECT * FROM Test2(); "Function Scan on test2 (cost=0.00..0.26 rows=1 width=4) (actual time=1.137..1.137 rows=1 loops=1)" "Total runtime: 1.153 ms" -- Wow EXPLAIN ANALYZE SELECT * FROM Test3(); "Function Scan on test3 (cost=0.00..0.26 rows=1 width=4) (actual time=2.033..2.034 rows=1 loops=1)" "Total runtime: 2.050 ms" EXPLAIN ANALYZE SELECT * FROM Test4(); "Function Scan on test4 (cost=0.00..0.26 rows=1 width=4) (actual time=2.001..2.001 rows=1 loops=1)" "Total runtime: 2.012 ms" In each case, the results are available outside the stored procedure by either fetching from the cursor or selecting from the temporary table. Clearly, the temporary table takes a performance hit compared using arrays. Building an array with array append is horrendously inefficient. Unnesting an array is surprisingly efficient. As can be seen from Test3 and Test4, cursors have no detectable overhead for opening the cursor (at least in this example with 1000 result rows). It is unclear whether there is any difference at all from Test3 and Test4 for retrieving the data as I have no easy way right now to measure that accurately. However, since arrays+cursors are more efficient than anything having to do with temp tables, that is the way I will go. With the number of rows I am dealing with (which should always be less than 1,000 in the final returned result set), unnesting an array is much faster than building a temp table and selecting from it. If anyone thinks I may have missed some important item in this testing, please let me know. On Fri, Apr 23, 2010 at 8:39 PM, Eliot Gable < egable+pgsql-performance@gmail.com >wrote: > That's a good point. However, even after changing it, it is still 12ms with > the function call verses 6ms without the extra function call. Though, it is > worth noting that if you can make the function call be guaranteed to return > the same results when used with the same input parameters, it ends up being > faster (roughly 3ms in my test case) due to caching -- at least when > executing it multiple times in a row like this. Unfortunately, I cannot take > advantage of that, because in my particular use case, the chances of it > being called again with the same input values within the cache lifetime of > the results is close to zero. Add to that the fact that the function queries > tables that could change between transactions (meaning the function is > volatile) and it's a moot point. However, it is worth noting that for those > people using a non-volatile function call multiple times in the same > transaction with the same input values, there is no need to inline the > function call. > > > On Fri, Apr 23, 2010 at 5:01 PM, Merlin Moncure wrote: > >> On Fri, Apr 23, 2010 at 4:42 PM, Eliot Gable >> > >> wrote: >> > To answer the question of whether calling a stored procedure adds any >> > significant overhead, I built a test case and the short answer is that >> it >> > seems that it does: >> > >> > CREATE OR REPLACE FUNCTION Test1() RETURNS INTEGER AS >> > $BODY$ >> > DECLARE >> > temp INTEGER; >> > BEGIN >> > FOR i IN 1..1000 LOOP >> > SELECT 1 AS id INTO temp; >> > END LOOP; >> > RETURN 1; >> > END; >> > $BODY$ >> > LANGUAGE plpgsql; >> > >> > CREATE OR REPLACE FUNCTION Test2A() RETURNS SETOF INTEGER AS >> > $BODY$ >> > DECLARE >> > BEGIN >> > RETURN QUERY SELECT 1 AS id; >> > END; >> > $BODY$ >> > LANGUAGE plpgsql; >> > >> > CREATE OR REPLACE FUNCTION Test2B() RETURNS INTEGER AS >> > $BODY$ >> > DECLARE >> > temp INTEGER; >> > BEGIN >> > FOR i IN 1..1000 LOOP >> > temp := Test2A(); >> > END LOOP; >> > RETURN 1; >> > END; >> > $BODY$ >> > LANGUAGE plpgsql; >> > >> > >> > EXPLAIN ANALYZE SELECT * FROM Test1(); >> > "Function Scan on test1 (cost=0.00..0.26 rows=1 width=4) (actual >> > time=6.568..6.569 rows=1 loops=1)" >> > "Total runtime: 6.585 ms" >> > >> > >> > EXPLAIN ANALYZE SELECT * FROM Test2B(); >> > "Function Scan on test2b (cost=0.00..0.26 rows=1 width=4) (actual >> > time=29.006..29.007 rows=1 loops=1)" >> > "Total runtime: 29.020 ms" >> >> That's not a fair test. test2a() is a SRF which has higher overhead >> than regular function. Try it this way and the timings will level >> out: >> >> CREATE OR REPLACE FUNCTION Test2A() RETURNS INTEGER AS >> $BODY$ >> DECLARE >> BEGIN >> RETURN 1 ; >> END; >> $BODY$ >> LANGUAGE plpgsql ; >> >> merlin >> > > > > -- > Eliot Gable > > "We do not inherit the Earth from our ancestors: we borrow it from our > children." ~David Brower > > "I decided the words were too conservative for me. We're not borrowing from > our children, we're stealing from them--and it's not even considered to be a > crime." ~David Brower > > "Esse oportet ut vivas, non vivere ut edas." (Thou shouldst eat to live; > not live to eat.) ~Marcus Tullius Cicero > -- Eliot Gable "We do not inherit the Earth from our ancestors: we borrow it from our children." ~David Brower "I decided the words were too conservative for me. We're not borrowing from our children, we're stealing from them--and it's not even considered to be a crime." ~David Brower "Esse oportet ut vivas, non vivere ut edas." (Thou shouldst eat to live; not live to eat.) ~Marcus Tullius Cicero --0016362848c29bc7d60484f2561b Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable
More benchmarking results are in with a comparison between cursors, ar= rays, and temporary tables for storing, using, and accessing data outside t= he stored procedure:

CREATE OR REPLACE FUNCTIO= N Test_Init() RETURNS INTEGER AS
$BODY$
DECLARE
=A0 =A0temp INTEGER;
BEGIN
=A0 =A0DROP TABLE IF = EXISTS test_table1 CASCADE;
=A0 =A0CREATE TABLE test_table1 (
=A0 =A0= =A0 id SERIAL NOT NULL PRIMARY KEY,
=A0 =A0 =A0 junk_field1 INTEGER,=A0 =A0 =A0 junk_field2 INTEGER,
=A0 =A0 =A0 junk_field3 INTEGER
=A0 =A0) WITH (OIDS=3DFALSE);
=A0 =A0= DROP INDEX IF EXISTS test_table1_junk_field1_idx CASCADE;
=A0 =A0DROP IN= DEX IF EXISTS test_table1_junk_field2_idx CASCADE;
=A0 =A0DROP INDEX IF = EXISTS test_table1_junk_field3_idx CASCADE;=A0
=A0 =A0FOR i IN 1..10000 LOOP
=A0 =A0 =A0 INSERT INTO test_table1 (junk_= field1, junk_field2, junk_field3) VALUES
=A0 =A0 =A0 =A0 (i%10, i%20, i= %30);
=A0 =A0END LOOP;
=A0 =A0CREATE INDEX test_table1_junk_field1_id= x ON test_table1 USING btree (junk_field1);
=A0 =A0CREATE INDEX test_table1_junk_field2_idx ON test_table1 USING btree = (junk_field2);
=A0 =A0CREATE INDEX test_table1_junk_field3_idx ON test_t= able1 USING btree (junk_field3);
=A0 =A0DROP TABLE IF EXISTS test_table2= CASCADE;
=A0 =A0CREATE TABLE test_table2 (
=A0 =A0 =A0 id SERIAL NOT NULL PRIMARY= KEY,
=A0 =A0 =A0 junk_field1 INTEGER,
=A0 =A0 =A0 junk_field2 INTEGE= R,
=A0 =A0 =A0 junk_field3 INTEGER
=A0 =A0) WITH (OIDS=3DFALSE);
= =A0 =A0DROP INDEX IF EXISTS test_table2_junk_field1_idx CASCADE;
=A0 =A0DROP INDEX IF EXISTS test_table2_junk_field2_idx CASCADE;
=A0 =A0= DROP INDEX IF EXISTS test_table2_junk_field3_idx CASCADE;=A0
=A0 =A0FOR = i IN 1..10000 LOOP
=A0 =A0 =A0 INSERT INTO test_table2 (junk_field1, jun= k_field2, junk_field3) VALUES
=A0 =A0 =A0 =A0 =A0 (i%15, i%25, i%35);
=A0 =A0END LOOP;
=A0 =A0CREA= TE INDEX test_table2_junk_field1_idx ON test_table2 USING btree (junk_field= 1);
=A0 =A0CREATE INDEX test_table2_junk_field2_idx ON test_table2 USING= btree (junk_field2);
=A0 =A0CREATE INDEX test_table2_junk_field3_idx ON test_table2 USING btree = (junk_field3);
=A0 =A0RETURN 1;
END;
$BODY$
LANGUAGE plpgsql;
SELECT * FROM Test_Init();

DROP TYPE IF EXISTS test_row_type C= ASCADE;
CREATE TYPE test_row_type AS (
=A0 =A0junk_field1 INTEGER,
=A0 =A0jun= k_field2 INTEGER,
=A0 =A0junk_field3 INTEGER
);

CREATE OR REPL= ACE FUNCTION Test1() RETURNS INTEGER AS
$BODY$
DECLARE
=A0 =A0temp= _row test_row_type;
=A0 =A0cursresults test_row_type[];
=A0 =A0curs SCROLL CURSOR IS
=A0 = =A0 =A0 SELECT * FROM test_table1 WHERE junk_field1=3D8;
BEGIN
=A0 = =A0 FOR temp IN curs LOOP
=A0 =A0 =A0 =A0temp_row :=3D temp;
=A0 =A0 = =A0 =A0cursresults :=3D array_append(cursresults, temp_row);
=A0 =A0 END LOOP;
=A0 =A0 OPEN curs;
=A0 =A0 RETURN 1;
END;
$BO= DY$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION Test2() RETURNS = INTEGER AS
$BODY$
DECLARE
cursresults test_row_type[];
=A0 =A0= cur SCROLL CURSOR IS
=A0 =A0 =A0SELECT * FROM unnest(cursresults);
BEGIN
=A0 =A0cursresult= s :=3D array(SELECT (junk_field1, junk_field2, junk_field3)::test_row_type = AS rec FROM test_table1 WHERE junk_field1=3D8);
=A0 =A0OPEN cur;
=A0 = =A0RETURN 1;
END;
$BODY$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION Test3() RETUR= NS INTEGER AS
$BODY$
DECLARE
BEGIN
=A0 =A0CREATE TEMPORARY TABL= E results WITH (OIDS=3DFALSE) ON COMMIT DROP AS (
=A0 =A0 =A0 SELECT jun= k_field1, junk_field2, junk_field3 FROM test_table1 WHERE junk_field1=3D8 =A0 =A0);
=A0 =A0RETURN 1;
END;
$BODY$
LANGUAGE plpgsql;
CREATE OR REPLACE FUNCTION Test4() RETURNS INTEGER AS
$BODY$
DECLARE=
=A0 =A0cur SCROLL CURSOR IS
=A0 =A0 =A0 SELECT * FROM results;
BE= GIN
=A0 =A0CREATE TEMPORARY TABLE results WITH (OIDS=3DFALSE) ON COMMIT = DROP AS (
=A0 =A0 =A0 SELECT junk_field1, junk_field2, junk_field3 FROM test_table1 W= HERE junk_field1=3D8
=A0=A0 );
=A0 =A0OPEN cur;
=A0 =A0RETURN 1;END;
$BODY$
LANGUAGE plpgsql;

EXPLAIN = ANALYZE SELECT * FROM Test1();
"Function Scan on test1 (cost=3D0.00..0.26 rows=3D1 width=3D4) (actua= l time=3D17.701..17.701 rows=3D1 loops=3D1)"
"Total runtime: 1= 7.714 ms" -- Ouch


EXPLAIN = ANALYZE SELECT * FROM Test2();
"Function Scan on test2 (cost=3D0.00..0.26 rows=3D1 width= =3D4) (actual time=3D1.137..1.137 rows=3D1 loops=3D1)"
"Total = runtime: 1.153 ms" -- Wow


= EXPLAIN ANALYZE SELECT * FROM Test3();
"Function Scan on test3 (cost=3D0.00..0.26 rows=3D1 width=3D4) (actua= l time=3D2.033..2.034 rows=3D1 loops=3D1)"
"Total runtime: 2.0= 50 ms"


EXPLAIN ANALYZE SELECT * FROM = Test4();
"Function Scan on test4 (cost=3D0.00..0.26 rows=3D1 width=3D4) (actua= l time=3D2.001..2.001 rows=3D1 loops=3D1)"
"Total runtime: 2.0= 12 ms"


In each case, the results are = available outside the stored procedure by either fetching from the cursor o= r selecting from the temporary table. Clearly, the temporary table takes a = performance hit compared using arrays. Building an array with array append = is horrendously inefficient. Unnesting an array is surprisingly efficient. = As can be seen from Test3 and Test4, cursors have no detectable overhead fo= r opening the cursor (at least in this example with 1000 result rows). It i= s unclear whether there is any difference at all from Test3 and Test4 for r= etrieving the data as I have no easy way right now to measure that accurate= ly. However, since arrays+cursors are more efficient than anything having t= o do with temp tables, that is the way I will go. With the number of rows I= am dealing with (which should always be less than 1,000 in the final retur= ned result set), unnesting an array is much faster than building a temp tab= le and selecting from it.=A0

If anyone thinks I may have missed some important item = in this testing, please let me know.


On Fri, Apr 23, 2010 at 8:39 PM, Eliot Gable <ega= ble+pgsql-performance@gmail.com> wrote:
That's a good point. However, even= after changing it, it is still 12ms with the function call verses 6ms with= out the extra function call. Though, it is worth noting that if you can mak= e the function call be guaranteed to return the same results when used with= the same input parameters, it ends up being faster (roughly 3ms in my test= case) due to caching -- at least when executing it multiple times in a row= like this. Unfortunately, I cannot take advantage of that, because in my p= articular use case, the chances of it being called again with the same inpu= t values within the cache lifetime of the results is close to zero. Add to = that the fact that the function queries tables that could change between tr= ansactions (meaning the function is volatile) and it's a moot point. Ho= wever, it is worth noting that for those people using a non-volatile functi= on call multiple times in the same transaction with the same input values, = there is no need to inline the function call.


= On Fri, Apr 23, 2010 at 5:01 PM, Merlin Moncure <mmoncure@gmail.com&g= t; wrote:
On Fri, Apr 23, 2010 at 4:42 PM, Eliot Gable
> To answer the question of whether calling a stored pro= cedure adds any
> significant overhead, I built a test case and the short answer is that= it
> seems that it does:
>
> CREATE OR REPLACE FUNCTION Test1() RETURNS INTEGER AS
> $BODY$
> DECLARE
> =A0=A0=A0 temp INTEGER;
> BEGIN
> =A0=A0=A0 FOR i IN 1..1000 LOOP
> =A0=A0=A0 =A0=A0=A0 SELECT 1 AS id INTO temp;
> =A0=A0=A0 END LOOP;
> =A0=A0=A0 RETURN 1;
> END;
> $BODY$
> LANGUAGE plpgsql;
>
> CREATE OR REPLACE FUNCTION Test2A() RETURNS SETOF INTEGER AS
> $BODY$
> DECLARE
> BEGIN
> =A0=A0=A0 RETURN QUERY SELECT 1 AS id;
> END;
> $BODY$
> LANGUAGE plpgsql;
>
> CREATE OR REPLACE FUNCTION Test2B() RETURNS INTEGER AS
> $BODY$
> DECLARE
> =A0=A0=A0 temp INTEGER;
> BEGIN
> =A0=A0=A0 FOR i IN 1..1000 LOOP
> =A0=A0=A0 =A0=A0=A0 temp :=3D Test2A();
> =A0=A0=A0 END LOOP;
> =A0=A0=A0 RETURN 1;
> END;
> $BODY$
> LANGUAGE plpgsql;
>
>
> EXPLAIN ANALYZE SELECT * FROM Test1();
> "Function Scan on test1=A0 (cost=3D0.00..0.26 rows=3D1 width=3D4)= (actual
> time=3D6.568..6.569 rows=3D1 loops=3D1)"
> "Total runtime: 6.585 ms"
>
>
> EXPLAIN ANALYZE SELECT * FROM Test2B();
> "Function Scan on test2b=A0 (cost=3D0.00..0.26 rows=3D1 width=3D4= ) (actual
> time=3D29.006..29.007 rows=3D1 loops=3D1)"
> "Total runtime: 29.020 ms"

That's not a fair test. =A0test2a() is a SRF which has high= er overhead
than regular function. =A0Try it this way and the timings will level
out:

CREATE OR REPLACE FUNCTION Test2A() RETURNS =A0INTEGER AS
$BODY$
DECLARE
BEGIN
=A0 =A0RETURN =A01 ;
END;
$BODY$
LANGUAGE plpgsql ;

merlin



--
Eliot Gable

"We do not inherit the Earth fro= m our ancestors: we borrow it from our children." ~David Brower
"I decided the words were too conservative for me. We're not borro= wing from our children, we're stealing from them--and it's not even= considered to be a crime." ~David Brower

"Esse oportet ut vivas, non vivere ut edas." (Thou shouldst e= at to live; not live to eat.) ~Marcus Tullius Cicero



--
Eliot Gable=

"We do not inherit the Earth from our ancestors: we borrow it = from our children." ~David Brower

"I decided the words we= re too conservative for me. We're not borrowing from our children, we&#= 39;re stealing from them--and it's not even considered to be a crime.&q= uot; ~David Brower

"Esse oportet ut vivas, non vivere ut edas." (Thou shouldst e= at to live; not live to eat.) ~Marcus Tullius Cicero
--0016362848c29bc7d60484f2561b--