select version();

create table t_test ( name text, valu integer );
insert into t_test select trunc( 10 *random()),trunc( 1000 *random())
  from generate_series(  1 ,  1000  );
create index i_test on t_test ( name );
analyze t_test;

set enable_bitmapscan to off;

explain select name, max(valu) from t_test
  where name between '1' and '3' group by name;
explain select name, max(valu) from t_test
  where name between '1' and '9' group by name;
select name, max(valu) from t_test
  where name between '1' and '3' group by name;
select name, max(valu) from t_test
  where name between '1' and '9' group by name;

create or replace function f_test(text,text) returns setof t_test as $$
  select name, max(valu) from t_test
    where name between $ 1  and $ 2  group by name
$$ language sql;
select * from f_test('1','3');
select * from f_test('1','9');

drop function f_test(text,text);
drop table t_test;

nalbat=> select version();
                                       version
-------------------------------------------------------------------------------------
 PostgreSQL  8 . 1 . 4  on i686-pc-linux-gnu, compiled by GCC gcc (GCC)  4 . 1 . 0  (SUSE Linux)
( 1  row)

nalbat=>
nalbat=> create table t_test ( name text, valu integer );
CREATE TABLE
nalbat=> insert into t_test select trunc( 10 *random()),trunc( 1000 *random())
nalbat->   from generate_series(  1 ,  1000  );
INSERT  0   1000 
nalbat=> create index i_test on t_test ( name );
CREATE INDEX
nalbat=> analyze t_test;
ANALYZE
nalbat=>
nalbat=> set enable_bitmapscan to off;
SET
nalbat=>
nalbat=> explain select name, max(valu) from t_test
nalbat->   where name between '1' and '3' group by name;
                                  QUERY PLAN
------------------------------------------------------------------------------
 GroupAggregate  (cost= 0 . 00 .. 21 . 20  rows= 3  width= 9 )
   ->  Index Scan using i_test on t_test  (cost= 0 . 00 .. 19 . 66  rows= 299  width= 9 )
         Index Cond: ((name >= '1'::text) AND (name <= '3'::text))
( 3  rows)

nalbat=> explain select name, max(valu) from t_test
nalbat->   where name between '1' and '9' group by name;
                          QUERY PLAN
---------------------------------------------------------------
 HashAggregate  (cost= 25 . 52 .. 25 . 64  rows= 10  width= 9 )
   ->  Seq Scan on t_test  (cost= 0 . 00 .. 21 . 00  rows= 904  width= 9 )
         Filter: ((name >= '1'::text) AND (name <= '9'::text))
( 3  rows)

nalbat=> select name, max(valu) from t_test
nalbat->   where name between '1' and '3' group by name;
 name | max
------+-----
  1     |  998 
  2     |  996 
  3     |  997 
( 3  rows)

nalbat=> select name, max(valu) from t_test
nalbat->   where name between '1' and '9' group by name;
 name | max
------+-----
  2     |  996 
  8     |  999 
  7     |  998 
  5     |  975 
  4     |  986 
  9     |  982 
  1     |  998 
  3     |  997 
  6     |  971 
( 9  rows)

nalbat=>
nalbat=> create or replace function f_test(text,text) returns setof t_test as $$
nalbat$>   select name, max(valu) from t_test
nalbat$>     where name between $ 1  and $ 2  group by name
nalbat$> $$ language sql;
CREATE FUNCTION
nalbat=> select * from f_test('1','3');
 name | valu
------+------
  1     |   998 
  2     |   996 
  3     |   997 
( 3  rows)

nalbat=> select * from f_test('1','9');
 name | valu
------+------
  1     |   998 
  2     |   996 
  3     |   997 
  4     |   986 
  5     |   975 
  6     |   971 
  7     |   998 
  8     |   999 
  9     |   982 
( 9  rows)

nalbat=>
nalbat=> drop function f_test(text,text);
DROP FUNCTION
nalbat=> drop table t_test;
DROP TABLE

CREATE OR REPLACE FUNCTION func(integer)
  RETURNS void LANGUAGE plpgsql AS $body$
DECLARE
  _rec record;
BEGIN
  for _rec in explain analyze
    select * from pg_class where relpages>$ 1  -- <-- проблемный запрос
  loop
    raise info '%', _rec."QUERY PLAN";
  end loop;
  return;
END;
$body$;

=> select func( 1 );
ERROR:  no value found for parameter  1 
CONTEXT:  PL/pgSQL function "func" line  4  at for over select rows

create table t1 ( id integer primary key );
insert into t1 select generate_series( 1 , 1000000 );
analyze t1;

create function f1 ( integer, integer )
  returns void language plpgsql as $body$
declare
  _rec record;
begin
  for _rec in explain
    select count(*) from t1 where id between $ 1  and $ 2 
  loop
    raise info '%', _rec."QUERY PLAN";
  end loop;
  return;
end;
$body$;

explain select count(*) from t1 where id between  1  and  1000 ;
select f1(  1 ,  1000  );

explain select count(*) from t1 where id between  1  and  1000000 ;
select f1(  1 ,  1000000  );

drop function f1 ( integer, integer );
drop table t1;

nalbat=> explain select count(*) from t1 where id between  1  and  1000 ;
                                QUERY PLAN
---------------------------------------------------------------------------
 Aggregate  (cost= 19 . 83 .. 19 . 84  rows= 1  width= 0 )
   ->  Index Scan using t1_pkey on t1  (cost= 0 . 00 .. 18 . 23  rows= 639  width= 0 )
         Index Cond: ((id >=  1 ) AND (id <=  1000 ))
( 3  rows)

nalbat=> select f1(  1 ,  1000  );
INFO:  Aggregate  (cost= 141 . 50 .. 141 . 51  rows= 1  width= 0 )
INFO:    ->  Index Scan using t1_pkey on t1  (cost= 0 . 00 .. 129 . 00  rows= 5000  width= 0 )
INFO:          Index Cond: ((id >= $ 1 ) AND (id <= $ 2 ))
 f1
----

( 1  row)

nalbat=>
nalbat=> explain select count(*) from t1 where id between  1  and  1000000 ;
                           QUERY PLAN
-----------------------------------------------------------------
 Aggregate  (cost= 22903 . 96 .. 22903 . 97  rows= 1  width= 0 )
   ->  Seq Scan on t1  (cost= 0 . 00 .. 20404 . 68  rows= 999712  width= 0 )
         Filter: ((id >=  1 ) AND (id <=  1000000 ))
( 3  rows)

nalbat=> select f1(  1 ,  1000000  );
INFO:  Aggregate  (cost= 141 . 50 .. 141 . 51  rows= 1  width= 0 )
INFO:    ->  Index Scan using t1_pkey on t1  (cost= 0 . 00 .. 129 . 00  rows= 5000  width= 0 )
INFO:          Index Cond: ((id >= $ 1 ) AND (id <= $ 2 ))
 f1
----

( 1  row)