CREATE TABLE schema_name.t_task_table (
  id BIGSERIAL,
  object_id INTEGER NOT NULL,
  task_type_id INTEGER NOT NULL,
  period pg_catalog.tstzrange,
  done BOOLEAN,
  registered_at TIMESTAMP(0) WITH TIME ZONE DEFAULT now() NOT NULL,
  postponed_until TIMESTAMP(0) WITH TIME ZONE DEFAULT now() NOT NULL,
  retry_count INTEGER DEFAULT 0 NOT NULL,
  last_error TEXT,
  last_try TIMESTAMP(0) WITH TIME ZONE,
  CONSTRAINT t_task_table_pkey PRIMARY KEY(id),
  CONSTRAINT fk_t_task_table_objectid FOREIGN KEY (object_id)
    REFERENCES schema_name.t_object(id)
    MATCH FULL
    ON DELETE CASCADE
    ON UPDATE CASCADE
    NOT DEFERRABLE
) 
WITH (oids = false);

CREATE UNIQUE INDEX idx_t_task_table_task_todo ON schema_name.t_task_table
  USING btree (object_id, id)
  WHERE (done IS NULL);

CREATE TRIGGER tr_t_task_table_a_i
  AFTER INSERT 
  ON schema_name.t_task_table
  
FOR EACH ROW 
  EXECUTE PROCEDURE gpt_common.ftr_t_task_table_a_i();

CREATE TRIGGER tr_t_task_table_a_u
  AFTER UPDATE OF done 
  ON schema_name.t_task_table
  
FOR EACH ROW 
  WHEN (new.done IS NULL)
EXECUTE PROCEDURE gpt_common.ftr_t_task_table_a_u();

CREATE TRIGGER tr_t_task_table_b_u_r
  BEFORE UPDATE 
  ON schema_name.t_task_table
  
FOR EACH ROW 
  EXECUTE PROCEDURE gpt_common.ftr_t_task_table_b_u_r();

CREATE OR REPLACE FUNCTION gpt_system.f_function_name (
  p_schema text,
  p_objectid integer
)
RETURNS TABLE (
  task_id bigint,
  period_from timestamptz,
  period_to timestamptz
) AS
$body$
DECLARE
  l_qry TEXT;
BEGIN
  l_qry := concat($$
  SELECT
    t2.id,
    t2."period_from",
    t2."period_to"
  FROM (
    SELECT
      0 AS t,
      t.id,
      t."period_from",
      t."period_to"
    FROM (
      SELECT
        trd.id,
        lower(trd.period) AS "period_from",
        upper(trd.period) AS "period_to"
      FROM
        $$, concat($1, '.t_task_table')::regclass, $$ AS trd
      WHERE
        trd.object_id = $1 AND
        trd.done IS NULL AND
        trd.postponed_until < now()
      ORDER BY
        trd.postponed_until
      LIMIT 1
      ) AS t

    UNION ALL

    SELECT 
      1 AS t,
      0::BIGINT AS "task_id",
      now() - (
        (INTERVAL '1 day' * c.default_task_interval) +
        (INTERVAL '1 day' * GREATEST(c.default_task_interval / 4, 1))
      ) AS "period_from",
      now() AS "period_to"
    FROM
      gpt_system.t_customer AS c  
    WHERE
      c.schema_name = $2 AND
      NOT EXISTS (
        SELECT
          1
        FROM
          $$, concat($1, '.t_object')::regclass, $$ AS oti
        WHERE
          oti.object_id = $1 AND
          oti.need_read_now = FALSE AND
          oti.last_downloaded >= (
            now() - (INTERVAL '1 day' * c.default_task_interval)
          )
        )
    ) AS t2
  ORDER BY
    t2.t
  LIMIT 1
  $$);
  
  RETURN QUERY
  EXECUTE l_qry
  USING $2, $1;
  
  RAISE LOG 'f_function_name(x,y) %', FOUND;
END;
$body$
LANGUAGE 'plpgsql'
STABLE
RETURNS NULL ON NULL INPUT
SECURITY INVOKER
COST 100 ROWS 1;

INSERT INTO schema_name.t_task_table (object_id, task_type_id, period) 
VALUES (13, 57, '["2017-01-31 02:00:00+02","2017-02-15 02:00:00+02"]'::tstzrange);