A PL/pgSQL function with varying return type (and varying inner query) - sql

Question

The data
Suppose I have the following data:
create temp table my_data1 (
id serial, val text
);
create temp table my_data2 (
id serial, val int
);
insert into my_data1(id, val)
values (default, 'a'), (default, 'c'), (default, 'd'), (default, 'b');
insert into my_data2(id, val)
values (default, 1), (default, 3), (default, 4), (default, 2);
The problem
I would like to write a plpgsql function which has 2 arguments: tbl (taking values my_data1 or my_data2) and order_by (which can be id or val or null). The function should fetch all rows from the table specified in tbl and order them by the column specified in order_by.
Below there are 2 solutions I have found (see also sqlfiddle). The question is which of them is preferable, and if there exists an even better solution.
Solution using temp table
I came up with the following workaround:
create function my_work(tbl text, order_by text default null)
returns text as
$my_work$
declare
q text;
begin
q := 'select * from ' || quote_ident(tbl);
if order_by is not null then
q := q || ' order by ' || quote_ident(order_by);
end if;
return q;
end
$my_work$ language plpgsql;
create function my_fetch(_query text, into_table text)
returns void as
$my_fetch$
begin
execute format($$
create temp table %I
on commit drop
as %s
$$, quote_ident(into_table), _query);
end
$my_fetch$ language plpgsql;
Then it remains to execute the following lines (preferably surrounded with 'begin/commit'):
select my_fetch(my_work('my_data1','id'), 'my_tmp');
select * from my_tmp;
Are there any negative side effects in this solution, e.g. is creating a temp table costy?
Another solution (using pg_typeof)
I've also read a great post on various approaches to dynamic queries with varying results. From the options mentioned there it seems the following is the best solution for my situation:
create or replace function not_my_work(_tbl_type anyelement, order_by text default null)
returns setof anyelement as
$func$
declare
q text;
begin
q := format('
select *
from %s
', pg_typeof(_tbl_type));
if order_by is not null then
q := q || ' order by ' || quote_ident(order_by);
end if;
return query execute q;
end
$func$ language plpgsql;
select not_my_work(null::my_data1, 'id');
Does this approach have any advantages over the approach using temp table?

Answer 1

I have two comments to the first solution.
First, use or %I or quote_ident() in format() function, not both. Compare:
with q(s) as (
values ('abba'), ('ABBA')
)
select
quote_ident(s) ok1,
format('%I', s) ok2,
format('%I', quote_ident(s)) bad_idea
from q;
ok1 | ok2 | bad_idea
--------+--------+------------
abba | abba | abba
"ABBA" | "ABBA" | """ABBA"""
(2 rows)
Second, you do not need two functions:
create or replace function my_select(into_table text, tbl text, order_by text default null)
returns void as $function$
declare
q text;
begin
q := 'select * from ' || quote_ident(tbl);
if order_by is not null then
q := q || ' order by ' || order_by;
end if;
execute format($$
create temp table %I
on commit drop
as %s
$$, into_table, q);
end
$function$ language plpgsql;
begin;
select my_select('my_tmp', 'my_data1', 'id');
select * from my_tmp;
commit;
BEGIN
my_select
-----------
(1 row)
id | val
----+-----
1 | a
2 | c
3 | d
4 | b
(4 rows)
COMMIT
In this particular case, the second solution is better.
A temporary table is not particularly expensive, but still unnecessary.
The cost will be the more important the more data in the table.
If you have a good alternative to create a temporary table, use it.
Besides, the need to include the function call and the select query in a transaction can be a bit cumbersome in some cases.
The second solution is smart and is ideally suited to the task at hand.