-- функция для копирования (создания таких же, как и у src-таблицы) ограничений - constraints
CREATE OR REPLACE FUNCTION copy_constraints(srcoid oid, dstoid oid)
  RETURNS integer AS
$BODY$
declare 
  i int4 :=  0 ;
  constrs record;
  srctable text;
  dsttable text;
begin
  srctable = srcoid::regclass;
  dsttable = dstoid::regclass;
  for constrs in 
  select conname as name, pg_get_constraintdef(oid) as definition 
  from pg_constraint where conrelid = srcoid loop
    begin
    execute 'alter table ' || dsttable 
      || ' add constraint ' 
      || replace(replace(constrs.name, srctable, dsttable),'.','_') 
      || ' ' || constrs.definition;
    i = i +  1 ;
    exception
      when duplicate_table then
    end;
  end loop;
  return i;
exception when undefined_table then
  return null;
end;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- перегрузим
CREATE OR REPLACE FUNCTION copy_constraints(src text, dst text)
  RETURNS integer AS
$BODY$
begin
  return copy_constraints(src::regclass::oid, dst::regclass::oid);
end;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;

-- функция для копирования индексов
CREATE OR REPLACE FUNCTION copy_indexes(srcoid oid, dstoid oid)
  RETURNS integer AS
$BODY$
declare 
  i int4 :=  0 ;
  indexes record;
  srctable text;
  dsttable text;
  script text;
begin
  srctable = srcoid::regclass;
  dsttable = dstoid::regclass;
  for indexes in 
  select c.relname as name, pg_get_indexdef(idx.indexrelid) as definition 
  from pg_index idx, pg_class c where idx.indrelid = srcoid and c.oid = idx.indexrelid loop
    script = replace (indexes.definition, ' INDEX ' 
      || indexes.name, ' INDEX ' 
      || replace(replace(indexes.name, srctable, dsttable),'.','_'));
    script = replace (script, ' ON ' || srctable, ' ON ' || dsttable);
    begin
      execute script;
      i = i +  1 ;
    exception
      when duplicate_table then 
    end;
  end loop;
  return i;
exception when undefined_table then
  return null;
end;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- перегрузим
CREATE OR REPLACE FUNCTION copy_indexes(src text, dst text)
  RETURNS integer AS
$BODY$
begin
  return copy_indexes(src::regclass::oid, dst::regclass::oid);
end;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;

-- функция для копирования триггеров (для партиционирования, они, собственно... хотя... ну мало ли, в общем :))
CREATE OR REPLACE FUNCTION copy_triggers(srcoid oid, dstoid oid)
  RETURNS integer AS
$BODY$
declare 
  i int4 :=  0 ;
  triggers record;
  srctable text;
  dsttable text;
  script text = '';
begin
  srctable = srcoid::regclass;
  dsttable = dstoid::regclass; 
  for triggers in 
   select tgname as name, pg_get_triggerdef(oid) as definition 
   from pg_trigger where tgrelid = srcoid loop
    script = 
    replace (triggers.definition, ' TRIGGER ' 
      || triggers.name, ' TRIGGER ' 
      || replace(replace(triggers.name, srctable, dsttable),'.','_'));
    script = replace (script, ' ON ' || srctable, ' ON ' || dsttable);
    begin
      execute script;
      i = i +  1 ;
    exception
      when duplicate_table then 
    end;
  end loop;
  return i;
exception when undefined_table then
  return null;
end;
$BODY$
LANGUAGE 'plpgsql' VOLATILE;

-- и тут перегрузим
CREATE OR REPLACE FUNCTION copy_triggers(src text, dst text)
  RETURNS integer AS
$BODY$
begin
  return copy_triggers(src::regclass::oid, dst::regclass::oid);
end;
$BODY$
LANGUAGE 'plpgsql' IMMUTABLE;

CREATE TABLE measurement (
    city_id         int not null,
    logdate         date not null,
    peaktemp        int,
    unitsales       int
);

 CREATE INDEX measurement_logdate ON measurement (logdate);
 CREATE INDEX measurement_peaktemp ON measurement (peaktemp);
 CREATE INDEX measurement_city_id ON measurement (city_id);
 -- забегая вперёд :-)
 COMMENT ON COLUMN measurement.logdate IS 'for partitioning';

CREATE OR REPLACE FUNCTION partition_month (parentoid oid, scheme character varying, dateval date)
  RETURNS text AS
$BODY$
declare 
  parent text := parentoid::regclass;
  suffix text := to_char (dateval, '_YYYY_MM'); 
  child  text := scheme || (select relname from pg_class where oid  = parentoid) || suffix;
  check_beg varchar;
  check_end varchar;
  check_condition varchar;
  check_field     varchar := null;
  tmp record;
  script text := '';
  i int :=  0 ;
  j int :=  0 ;
begin
  -- таблица уже существует
  perform child::regclass;
  return child;
exception 
  when undefined_table then
    -- интервалы для constraint check
    check_beg = to_char (dateval,'YYYY-MM-01');
    check_end = to_char (check_beg::date + interval '1 month' - interval '1 day','YYYY-MM-DD');

    -- пробегаемся по полям родительской таблицы, составляем values для insert rule
    j = (select count(*) from pg_attribute where attrelid = parentoid  and attnum > 0 );
    for tmp in 
    select attname from pg_attribute where attrelid = parentoid and attnum > 0  order by attnum loop
      i = i +  1 ;
      script = script || 'NEW.' || tmp.attname || case i when j then '' else ',' end;
      -- заодно выясняем поле для партиционирования и составления условия проверки
      if (col_description (parentoid, i) ~* 'partition') and (check_field is null) 
        then check_field = tmp.attname; end if;
    end loop;
    script = script || ')';

    -- условие для проверки
    check_condition =      
    '( 
       ' || check_field || ' >= ' || quote_literal (check_beg) || ' and 
       ' || check_field || ' <= ' || quote_literal (check_end) || ' 
     )';

    -- создаём child-таблицу
    execute 
    'create table ' || child || '
    (
     constraint partition' || suffix || ' check ' 
      || check_condition || '
    ) 
    inherits (' || parent || ')'; 

    -- создаём правило для parent-таблицы
    execute 
    'create rule route' || suffix || ' as '
      || ' on insert to ' || parent || ' where '
      || check_condition
      || ' do instead insert into ' || child
      || ' values (' || script;

    -- копируем ключи и индексы
    perform copy_constraints(parent, child);
    perform copy_indexes(parent, child);
  return child;
end;
$BODY$
LANGUAGE 'plpgsql';

  create schema partitions;
  select partition_month('measurement'::regclass::oid, 'partitions.', current_date);

CREATE OR REPLACE FUNCTION measurement_router_trig()
  RETURNS "trigger" AS
$BODY$
begin 
  perform partition_month (TG_RELID, 'partitions.', NEW.logdate);
  return NEW;
end;
$BODY$
LANGUAGE 'plpgsql' immutable;

CREATE TRIGGER measurement_router BEFORE INSERT ON measurement 
  FOR EACH ROW EXECUTE PROCEDURE measurement_router_trig();

insert into measurement
 select round(random()* 1000 ), (y||'-'|| m||'-'||d)::date, round(random()* 1000 ), round(random()* 1000 ) 
 from generate_series( 2000 , 2005 ) y, generate_series( 1 , 12 ) m, generate_series ( 1 ,  15 ) d;

                  первая вставка / вторая (когда таблицы создавать уже не нужно)
rule:             10             / 6.5 (5.5)
триггер, plpgsql: 8              / 2.5
триггер, си:      7              / 1.6

Теорию Вы можете прочитать здесь, а ниже мы рассмотрим, как на практике использовать данный метод.

CREATE OR REPLACE RULE out_insert_out_yy06mm01 AS
ON INSERT TO data."out"

  foreach year { 06   07 } {
    foreach month { 01   02   03   04   05   06   07   08   09   10   11   12 }