pg_restore: [archiver (db)] Error while PROCESSING TOC:
pg_restore: [archiver (db)] Error from TOC entry 1193; 1255 47395439 FUNCTION apaga_arvore(bigint, character varying, character varying) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "apaga_arvore" already exists with same argument types
    Command was: CREATE FUNCTION public.apaga_arvore(bigint, character varying, character varying) RETURNS integer
    LANGUAGE plpgsql SECURITY DEFINER
    AS $_$
declare
  vseq alias for $1;
  vusuario alias for $2;
  vtabela alias for $3;
  vmaior int4;
  vesq int4;
  vdir int4;
  vdir_novo int4;
  vesq_novo int4;
  vnivel int4;
  vnova_seq int4;
   vsql text;
  qaux record;

begin
  vsql := 'select esq,dir  from '||vtabela||' where seq_'||vtabela||' ='||vseq::text;

  for qaux in execute vsql loop
    vesq:=qaux.esq;
    vdir:=qaux.dir;
  end loop;

  vsql:=' update '||vtabela||' set esq=esq-2, dir=dir-2 where esq > '||vesq::text; --Todos do outros ramos a direita
  raise notice '% %',vsql,vesq;
  execute vsql;
  vsql:='update '||vtabela||' set dir=dir-2 where '||vesq::text||' BETWEEN esq AND dir'; --Todos do mesmo ramos
  raise notice '%',vsql;
  execute vsql;

  vnova_seq :=vseq;

  vsql:='delete from '||vtabela||' where seq_'||vtabela||' = '||vseq::text;
  raise notice '%',vsql;
  execute vsql;

  return vnova_seq;
end;
$_$;



pg_restore: creating FUNCTION "public.cobranca_adiciona_taxa(integer)"
pg_restore: [archiver (db)] Error from TOC entry 1206; 1255 47395440 FUNCTION cobranca_adiciona_taxa(integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "cobranca_adiciona_taxa" already exists with same argument types
    Command was: CREATE FUNCTION public.cobranca_adiciona_taxa(pmatricula integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $$

declare
  rMatr  record;
  rPT    record;
  rC     record;
  rQ     record;
  rT     record;
  rPgto  record;
  rUltData date;
  rVenc    date;
  i         int;
  iMovi     int;
begin

  -- Dados da matricula
  FOR rMatr IN SELECT m.seq_produto
            , m.seq_plano_pgto
            , m.matricula
            , m.data_aquisicao
            , pt.ciclico
            , pt.periodicidade
            , ppp.seq_produto_taxa
            , m.dia_cobranca
            , pt.valor
              , m.seq_pessoa
              , pt.numero_vezes

              , pr.seq_produto_classe
              , (SELECT MAX(data_fim)
                     FROM movimento_cobranca AS mc
                     JOIN competencia AS c USING(competencia)
                     JOIN produto_taxa AS pt USING(seq_produto_taxa)
                    WHERE matricula = m.matricula
                  AND seq_produto_taxa = ppp.seq_produto_taxa) AS dt_ultima
          FROM matricula AS m
          JOIN produto_plano_pgto AS ppp ON (ppp.seq_plano_pgto = m.seq_plano_pgto)
          JOIN produto_taxa AS pt USING (seq_produto_taxa)

          join produto as pr on pr.seq_produto=m.seq_produto
         WHERE m.matricula = pmatricula LOOP

    rUltData := COALESCE(rMatr.dt_ultima, rMatr.data_aquisicao);

     -- A cobranca repete?
    IF COALESCE(rMatr.ciclico, FALSE) THEN


      -- Mensal?
      IF (rMatr.periodicidade = 'Mensal') THEN



        --Pega ultima data aberta
        SELECT MAX(data_fim) as ult,count(mc.matricula) as tt
               INTO rT
               FROM movimento_cobranca AS mc
               JOIN competencia AS c USING(competencia)
               JOIN produto_taxa AS pt USING(seq_produto_taxa)
              WHERE matricula = pmatricula
                and mc.data_pagamento is null;


            raise notice 'fazendo % %',rT.tt, rT.ult;

        IF (rT.tt<12) THEN

             SELECT MAX(data_fim) AS data_fim
               INTO rPgto
               FROM movimento_cobranca
               JOIN competencia AS c USING(competencia)
               JOIN produto_taxa AS pt USING(seq_produto_taxa)
              WHERE matricula = pmatricula
                AND data_pagamento IS NOT NULL;

              IF (rPgto.data_fim IS NULL) THEN
                rUltData := COALESCE(rT.ult, rMatr.data_aquisicao);
              ELSE
                rUltData := COALESCE(rPgto.data_fim, rMatr.data_aquisicao);
              END IF;

              FOR i IN 1..(12-rT.tt) LOOP
        SELECT c.competencia
               , TO_DATE(TO_CHAR(data_ini, 'yyyy-mm')||'-'||TO_CHAR(rMatr.dia_cobranca, 'dd'), 'yyyy-mm-dd') AS dt_vencimento
               , c.data_ini
          INTO rC
          FROM competencia AS c
         WHERE periodicidade = rMatr.periodicidade
           AND data_ini > rUltData

           and not((rMatr.seq_produto_classe=5) and (substr(c.competencia,1,2) in ('01','02')))
        ORDER BY c.data_ini
         LIMIT 1;

        rVenc := rC.data_ini;



    if not((rMatr.seq_produto_classe=5) and (substr(rC.competencia,1,2) in ('01','02')))  then --ESCOLINHA NAO ENTRA JAN E FEV ELVIS 11-01-2018
      INSERT INTO movimento_cobranca
         (matricula, seq_produto_taxa, valor_devido, valor_pago, data_vencimento, data_pagamento
         ,data_cancelamento, usuario_alteracao, data_alteracao, seq_pessoa, competencia)
      VALUES
         ( pmatricula,
           rMatr.seq_produto_taxa,
           rMatr.valor, --valor_devido,
           null, -- valor_pago,
           rC.dt_vencimento, --data_vencimento,
           null, -- data_pagamento,
           null, --data_cancelamento,
           -78, --usuario_alteracao,
           now(), --data_alteracao,
           rMatr.seq_pessoa,
           rC.competencia);
            SELECT rUltData + interval '1 month' INTO rUltData;

      end if;
        END LOOP;
    end if; --IF (rT.tt<12)
      ELSE
    -- Anual
    raise notice 'Anuidade: %', rMatr.dt_ultima;
    IF ((rMatr.dt_ultima IS NULL) OR (NOW() > rMatr.dt_ultima + interval '1 year')) THEN

      SELECT c.competencia
         , TO_DATE(TO_CHAR(data_ini, 'yyyy-mm')||'-'||TO_CHAR(rMatr.dia_cobranca, 'dd'), 'yyyy-mm-dd') AS dt_vencimento
         , c.data_ini
        INTO rC
        FROM competencia AS c
       WHERE periodicidade = 'Mensal'
         AND data_ini > rUltData

         and not((rMatr.seq_produto_classe=5) and (substr(c.competencia,1,2) in ('01','02')))
      ORDER BY c.data_ini
       LIMIT 1;


    if not((rMatr.seq_produto_classe=5) and (substr(rC.competencia,1,2) in ('01','02')))  then --ESCOLINHA NAO ENTRA JAN E FEV ELVIS 11-01-2018


      INSERT INTO movimento_cobranca
           (matricula, seq_produto_taxa, valor_devido, valor_pago, data_vencimento, data_pagamento
           ,data_cancelamento, usuario_alteracao, data_alteracao, seq_pessoa, competencia)
        VALUES
           ( pmatricula,
           rMatr.seq_produto_taxa,
           rMatr.valor, --valor_devido,
           null, -- valor_pago,
           rC.dt_vencimento, --data_vencimento,
           null, -- data_pagamento,
           null, --data_cancelamento,
           -78, --usuario_alteracao,
           now(), --data_alteracao,
           rMatr.seq_pessoa,
           rC.competencia);

      end if;

    END IF;
      END IF;

    ELSE

    -- Verifica se ja possui o numero de vezes e a primeira competencia
    SELECT COUNT(*) AS tt
      INTO iMovi
      FROM movimento_cobranca
     WHERE matricula   = rMatr.matricula
       AND seq_produto_taxa = rMatr.seq_produto_taxa;

    IF (iMovi = 0) THEN

      -- Insere os movimentos (loop no numero_vezes incrementando mensalmente)
      FOR i IN 1..rMatr.numero_vezes LOOP

        SELECT c.competencia
           , TO_DATE(TO_CHAR(data_ini, 'yyyy-mm')||'-'||TO_CHAR(rMatr.dia_cobranca, 'dd'), 'yyyy-mm-dd') AS dt_vencimento
           , c.data_ini
          INTO rC
          FROM competencia AS c
         WHERE periodicidade = 'Mensal'
           AND data_ini > rUltData

           and not((rMatr.seq_produto_classe=5) and (substr(c.competencia,1,2) in ('01','02')))
        ORDER BY c.data_ini
         LIMIT 1;

         INSERT INTO movimento_cobranca
           (matricula, seq_produto_taxa, valor_devido, valor_pago, data_vencimento, data_pagamento
           ,data_cancelamento, usuario_alteracao, data_alteracao, seq_pessoa, competencia)
        VALUES
           ( pmatricula,
           rMatr.seq_produto_taxa,
           rMatr.valor, --valor_devido,
           null, -- valor_pago,
           rC.dt_vencimento, --data_vencimento,
           null, -- data_pagamento,
           null, --data_cancelamento,
           -78, --usuario_alteracao,
           now(), --data_alteracao,
           rMatr.seq_pessoa,
           rC.competencia);

        SELECT rUltData + interval '1 month' INTO rUltData;

      END LOOP;

    END IF;
      raise notice 'Tem? %', rUltData;
    END IF;

  END LOOP;

  RETURN 'OK';
END;

$$;



pg_restore: creating FUNCTION "public.cobranca_adiciona_taxa(integer, integer)"
pg_restore: [archiver (db)] Error from TOC entry 1207; 1255 47395441 FUNCTION cobranca_adiciona_taxa(integer, integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "cobranca_adiciona_taxa" already exists with same argument types
    Command was: CREATE FUNCTION public.cobranca_adiciona_taxa(pmatricula integer, pseq_produto_taxa integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $$
declare
  rPT record;
  rC record;
  rQ record;
  rUltData date;
  rVenc date;
Begin

   select * into rPT
     from taxa as t
     join produto_taxa as pt using(seq_taxa)
    where seq_produto_taxa= pseq_produto_taxa;

   if coalesce(rPT.ciclico,false) then --Verifica qual data falta
      if rPT.periodicidade='Mensal' then

         select max(data_fim) into rUltData
           from movimento_cobranca as mc
           join competencia as c using(competencia)
           join produto_taxa as pt using(seq_produto_taxa)
          where seq_produto_taxa= pseq_produto_taxa;

         rUltData:=coalesce(rUltData,now());

         select * into rC
           from competencia as c
          where periodicidade=rPT.periodicidade
           and data_ini>rUltData
         order by c.data_ini
           limit 1;

         rVenc:=rC.data_ini;

        INSERT INTO movimento_cobranca(
             matricula, seq_produto_taxa, valor_devido,
            valor_pago, data_vencimento, data_pagamento, data_cancelamento,
            usuario_alteracao, data_alteracao, seq_pessoa, competencia)
         VALUES (
               pmatricula,
               pseq_produto_taxa,
               rPT.valor, --valor_devido,
               null, -- valor_pago,
               rVenc, --data_vencimento,
               null, -- data_pagamento,
               null, --data_cancelamento,
               -78, --usuario_alteracao,
               now(), --data_alteracao,
               (select seq_pessoa from matricula where matricula=pmatricula),
               rC.competencia);


      end if;


   end if;



   return 'OK';
end;

$$;



pg_restore: creating FUNCTION "public.competencia_atual()"
pg_restore: [archiver (db)] Error from TOC entry 1215; 1255 49625524 FUNCTION competencia_atual() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "competencia_atual" already exists with same argument types
    Command was: CREATE FUNCTION public.competencia_atual() RETURNS character varying
    LANGUAGE plpgsql
    AS $$

 declare

   lsCompetencia varchar;

begin

select competencia into lsCompetencia from competencia where data_ini<=now()::date and data_fim >= now()::date;


return lsCompetencia;


end;$$;



pg_restore: creating FUNCTION "public.concate(text, text)"
pg_restore: [archiver (db)] Error from TOC entry 1208; 1255 47395442 FUNCTION concate(text, text) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "concate" already exists with same argument types
    Command was: CREATE FUNCTION public.concate(text, text) RETURNS text
    LANGUAGE sql
    AS $_$
SELECT COALESCE($2 ||', '|| $1,$1,$2,NULL)
$_$;



pg_restore: creating FUNCTION "public.concatefinal(text)"
pg_restore: [archiver (db)] Error from TOC entry 1209; 1255 47395443 FUNCTION concatefinal(text) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "concatefinal" already exists with same argument types
    Command was: CREATE FUNCTION public.concatefinal(text) RETURNS text
    LANGUAGE sql
    AS $_$
SELECT substr($1,1,length($1))
$_$;



pg_restore: creating FUNCTION "public.depois_inserir_sessao()"
pg_restore: [archiver (db)] Error from TOC entry 1210; 1255 47395444 FUNCTION depois_inserir_sessao() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "depois_inserir_sessao" already exists with same argument types
    Command was: CREATE FUNCTION public.depois_inserir_sessao() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
declare
  rQ record;
begin
   for rQ in select *
               from evento_produto as ep
              where ep.seq_evento=new.seq_evento

                and not exists (select 1
                                  from sessao_evento_produto as ss1
                                  join evento_produto as ep1 using(seq_evento_produto)
                                 where ep1.seq_evento=new.seq_evento
                                   and ss1.seq_sessao = new.seq_sessao
                                   and ss1.seq_evento_produto = ep.seq_evento_produto) loop
       INSERT INTO sessao_evento_produto(
            seq_sessao, seq_evento_produto, qtde,
            dt_carga, seq_supervisor, usuario_alteracao, data_alteracao)
      VALUES (
            new.seq_sessao,
            rQ.seq_evento_produto,
            500,
            null, --dt_carga,
            null, --seq_supervisor,
            'Andre e Buddy', --usuario_alteracao,
            now()); --data_alteracao);

   end loop;

   return new;
end; $$;



pg_restore: creating FUNCTION "public.em_dia(integer, character varying)"
pg_restore: [archiver (db)] Error from TOC entry 1230; 1255 49629109 FUNCTION em_dia(integer, character varying) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "em_dia" already exists with same argument types
    Command was: CREATE FUNCTION public.em_dia(pimatricula integer, pscompetencia character varying) RETURNS boolean
    LANGUAGE plpgsql
    AS $$

 declare

   liqtde integer;

   lscompetencia varchar(10);

begin



if pscompetencia is null then

  lscompetencia := competencia_atual();

else

  lscompetencia := pscompetencia;

end if;


select count(seq_movimento_cobranca)

  into liqtde

from movimento_cobranca

where matricula = pimatricula

  and valor_pago is not null

  and competencia = lscompetencia;



  return liqtde > 0;




end;$$;



pg_restore: creating FUNCTION "public.estorna_movimento()"
pg_restore: [archiver (db)] Error from TOC entry 1211; 1255 47395445 FUNCTION estorna_movimento() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "estorna_movimento" already exists with same argument types
    Command was: CREATE FUNCTION public.estorna_movimento() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
declare
   rEventoProduto  record;
   rIngressoNumero record;
   vseq_ingresso   int4;
   ieven_ref       Integer;
begin
   -- se tiver data de estorno, gera o cancelamento dos ingressos gerados pela movimento_item --
   if new.data_estorno is not null then
      update ingresso set dt_cancelamento = new.data_estorno where seq_movimento_item in (select seq_movimento_item from movimento_item where seq_movimento = new.seq_movimento);
   end if;

   return new;
end; $$;



pg_restore: creating FUNCTION "public.fatura_retorno()"
pg_restore: [archiver (db)] Error from TOC entry 1212; 1255 47395446 FUNCTION fatura_retorno() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fatura_retorno" already exists with same argument types
    Command was: CREATE FUNCTION public.fatura_retorno() RETURNS integer
    LANGUAGE plpgsql
    AS $$

declare
  rRetorno  record;

  licont integer;
begin

  licont := 0;
  for rRetorno in (select *

                     from public.cobranca_retorno

                    where dt_lido_sistema is null

                    order by seq_cobranca_retorno) loop

     licont := licont + 1;

     if rRetorno.cod_ocorrencia = '06' then

       update public.cobranca_titulo

          set status = rRetorno.cod_ocorrencia,

              data_alteracao = now(),

              usuario_alteracao = 'fatura_retorno_pgto',

              valor_pago =  rRetorno.vlr_pago::numeric/100,

              data_pagamento = rRetorno.dt_credito

        where nosso_numero = rRetorno.nosso_numero;

      else

       update public.cobranca_titulo

          set status = rRetorno.cod_ocorrencia,

              data_alteracao = now(),

              usuario_alteracao = 'fatura_retorno'

        where nosso_numero = rRetorno.nosso_numero;

     end if;

     update public.cobranca_retorno set dt_lido_sistema = now() where seq_cobranca_retorno = rRetorno.seq_cobranca_retorno;

  end loop;

  return licont;
end;
$$;



pg_restore: creating FUNCTION "public.fnc_abertura_jogo(date)"
pg_restore: [archiver (db)] Error from TOC entry 1213; 1255 47395447 FUNCTION fnc_abertura_jogo(date) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_abertura_jogo" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_abertura_jogo(pdia date) RETURNS character varying
    LANGUAGE plpgsql
    AS $$
declare
 rQ record;
 i integer;
 vE integer;
 vCB varchar(200);
 vCP integer;
 vTem integer;
Begin

-- acesso historico
select seq_evento into vE from evento where dt_evento::date= (select min(data_acesso)::date from acesso);
insert into acesso_historico ( --seq_acesso_historico, codigo, status, data_acesso, usuario_alteracao,
      --seq_evento, seq_produto, seq_catraca, data_alteracao, tipo
SELECT nextval('acesso_historico_seq_acesso_historico_seq'), a.codigo, a.status, a.data_acesso, l.usuario_alteracao,
       vE, l.seq_produto, a.seq_catraca, a.data_alteracao, a.tipo, l.mensagem
  FROM acesso as a
  left join liberacao as l using(codigo)
 --where seq_acesso not in (SELECT seq_acesso_historico from acesso_historico)
);
delete from acesso;

insert into liberacao_historico (
SELECT nextval('seq_liberacao_historico'), seq_liberacao, codigo, seq_produto,
       status, data_acesso, usuario_alteracao, data_alteracao, tipo_acesso,
       mensagem, vE
  FROM liberacao
);
delete from liberacao;

--for rQ in Select * from socio_tmp loop
for rQ in select cod_barra as codigo
            from matricula as m
            join cartao as c using (matricula)
           where em_dia
           loop

select seq_liberacao into vTem from liberacao where codigo=rQ.codigo;

if vTem is null then

insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
pg_restore: connecting to database for restore
pg_restore: creating SCHEMA "public"
pg_restore: creating COMMENT "SCHEMA public"
pg_restore: creating FUNCTION "public.apaga_arvore(bigint, character varying, character varying)"
pg_restore: [archiver (db)] Error while PROCESSING TOC:
pg_restore: [archiver (db)] Error from TOC entry 1193; 1255 47395439 FUNCTION apaga_arvore(bigint, character varying, character varying) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "apaga_arvore" already exists with same argument types
    Command was: CREATE FUNCTION public.apaga_arvore(bigint, character varying, character varying) RETURNS integer
    LANGUAGE plpgsql SECURITY DEFINER
    AS $_$
declare
  vseq alias for $1;
  vusuario alias for $2;
  vtabela alias for $3;
  vmaior int4;
  vesq int4;
  vdir int4;
  vdir_novo int4;
  vesq_novo int4;
  vnivel int4;
  vnova_seq int4;
   vsql text;
  qaux record;

begin
  vsql := 'select esq,dir  from '||vtabela||' where seq_'||vtabela||' ='||vseq::text;

  for qaux in execute vsql loop
    vesq:=qaux.esq;
    vdir:=qaux.dir;
  end loop;

  vsql:=' update '||vtabela||' set esq=esq-2, dir=dir-2 where esq > '||vesq::text; --Todos do outros ramos a direita
  raise notice '% %',vsql,vesq;
  execute vsql;
  vsql:='update '||vtabela||' set dir=dir-2 where '||vesq::text||' BETWEEN esq AND dir'; --Todos do mesmo ramos
  raise notice '%',vsql;
  execute vsql;

  vnova_seq :=vseq;

  vsql:='delete from '||vtabela||' where seq_'||vtabela||' = '||vseq::text;
  raise notice '%',vsql;
  execute vsql;

  return vnova_seq;
end;
$_$;



pg_restore: creating FUNCTION "public.cobranca_adiciona_taxa(integer)"
pg_restore: [archiver (db)] Error from TOC entry 1206; 1255 47395440 FUNCTION cobranca_adiciona_taxa(integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "cobranca_adiciona_taxa" already exists with same argument types
    Command was: CREATE FUNCTION public.cobranca_adiciona_taxa(pmatricula integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $$

declare
  rMatr  record;
  rPT    record;
  rC     record;
  rQ     record;
  rT     record;
  rPgto  record;
  rUltData date;
  rVenc    date;
  i         int;
  iMovi     int;
begin

  -- Dados da matricula
  FOR rMatr IN SELECT m.seq_produto
            , m.seq_plano_pgto
            , m.matricula
            , m.data_aquisicao
            , pt.ciclico
            , pt.periodicidade
            , ppp.seq_produto_taxa
            , m.dia_cobranca
            , pt.valor
              , m.seq_pessoa
              , pt.numero_vezes

              , pr.seq_produto_classe
              , (SELECT MAX(data_fim)
                     FROM movimento_cobranca AS mc
                     JOIN competencia AS c USING(competencia)
                     JOIN produto_taxa AS pt USING(seq_produto_taxa)
                    WHERE matricula = m.matricula
                  AND seq_produto_taxa = ppp.seq_produto_taxa) AS dt_ultima
          FROM matricula AS m
          JOIN produto_plano_pgto AS ppp ON (ppp.seq_plano_pgto = m.seq_plano_pgto)
          JOIN produto_taxa AS pt USING (seq_produto_taxa)

          join produto as pr on pr.seq_produto=m.seq_produto
         WHERE m.matricula = pmatricula LOOP

    rUltData := COALESCE(rMatr.dt_ultima, rMatr.data_aquisicao);

     -- A cobranca repete?
    IF COALESCE(rMatr.ciclico, FALSE) THEN


      -- Mensal?
      IF (rMatr.periodicidade = 'Mensal') THEN



        --Pega ultima data aberta
        SELECT MAX(data_fim) as ult,count(mc.matricula) as tt
               INTO rT
               FROM movimento_cobranca AS mc
               JOIN competencia AS c USING(competencia)
               JOIN produto_taxa AS pt USING(seq_produto_taxa)
              WHERE matricula = pmatricula
                and mc.data_pagamento is null;


            raise notice 'fazendo % %',rT.tt, rT.ult;

        IF (rT.tt<12) THEN

             SELECT MAX(data_fim) AS data_fim
               INTO rPgto
               FROM movimento_cobranca
               JOIN competencia AS c USING(competencia)
               JOIN produto_taxa AS pt USING(seq_produto_taxa)
              WHERE matricula = pmatricula
                AND data_pagamento IS NOT NULL;

              IF (rPgto.data_fim IS NULL) THEN
                rUltData := COALESCE(rT.ult, rMatr.data_aquisicao);
              ELSE
                rUltData := COALESCE(rPgto.data_fim, rMatr.data_aquisicao);
              END IF;

              FOR i IN 1..(12-rT.tt) LOOP
        SELECT c.competencia
               , TO_DATE(TO_CHAR(data_ini, 'yyyy-mm')||'-'||TO_CHAR(rMatr.dia_cobranca, 'dd'), 'yyyy-mm-dd') AS dt_vencimento
               , c.data_ini
          INTO rC
          FROM competencia AS c
         WHERE periodicidade = rMatr.periodicidade
           AND data_ini > rUltData

           and not((rMatr.seq_produto_classe=5) and (substr(c.competencia,1,2) in ('01','02')))
        ORDER BY c.data_ini
         LIMIT 1;

        rVenc := rC.data_ini;



    if not((rMatr.seq_produto_classe=5) and (substr(rC.competencia,1,2) in ('01','02')))  then --ESCOLINHA NAO ENTRA JAN E FEV ELVIS 11-01-2018
      INSERT INTO movimento_cobranca
         (matricula, seq_produto_taxa, valor_devido, valor_pago, data_vencimento, data_pagamento
         ,data_cancelamento, usuario_alteracao, data_alteracao, seq_pessoa, competencia)
      VALUES
         ( pmatricula,
           rMatr.seq_produto_taxa,
           rMatr.valor, --valor_devido,
           null, -- valor_pago,
           rC.dt_vencimento, --data_vencimento,
           null, -- data_pagamento,
           null, --data_cancelamento,
           -78, --usuario_alteracao,
           now(), --data_alteracao,
           rMatr.seq_pessoa,
           rC.competencia);
            SELECT rUltData + interval '1 month' INTO rUltData;

      end if;
        END LOOP;
    end if; --IF (rT.tt<12)
      ELSE
    -- Anual
    raise notice 'Anuidade: %', rMatr.dt_ultima;
    IF ((rMatr.dt_ultima IS NULL) OR (NOW() > rMatr.dt_ultima + interval '1 year')) THEN

      SELECT c.competencia
         , TO_DATE(TO_CHAR(data_ini, 'yyyy-mm')||'-'||TO_CHAR(rMatr.dia_cobranca, 'dd'), 'yyyy-mm-dd') AS dt_vencimento
         , c.data_ini
        INTO rC
        FROM competencia AS c
       WHERE periodicidade = 'Mensal'
         AND data_ini > rUltData

         and not((rMatr.seq_produto_classe=5) and (substr(c.competencia,1,2) in ('01','02')))
      ORDER BY c.data_ini
       LIMIT 1;


    if not((rMatr.seq_produto_classe=5) and (substr(rC.competencia,1,2) in ('01','02')))  then --ESCOLINHA NAO ENTRA JAN E FEV ELVIS 11-01-2018


      INSERT INTO movimento_cobranca
           (matricula, seq_produto_taxa, valor_devido, valor_pago, data_vencimento, data_pagamento
           ,data_cancelamento, usuario_alteracao, data_alteracao, seq_pessoa, competencia)
        VALUES
           ( pmatricula,
           rMatr.seq_produto_taxa,
           rMatr.valor, --valor_devido,
           null, -- valor_pago,
           rC.dt_vencimento, --data_vencimento,
           null, -- data_pagamento,
           null, --data_cancelamento,
           -78, --usuario_alteracao,
           now(), --data_alteracao,
           rMatr.seq_pessoa,
           rC.competencia);

      end if;

    END IF;
      END IF;

    ELSE

    -- Verifica se ja possui o numero de vezes e a primeira competencia
    SELECT COUNT(*) AS tt
      INTO iMovi
      FROM movimento_cobranca
     WHERE matricula   = rMatr.matricula
       AND seq_produto_taxa = rMatr.seq_produto_taxa;

    IF (iMovi = 0) THEN

      -- Insere os movimentos (loop no numero_vezes incrementando mensalmente)
      FOR i IN 1..rMatr.numero_vezes LOOP

        SELECT c.competencia
           , TO_DATE(TO_CHAR(data_ini, 'yyyy-mm')||'-'||TO_CHAR(rMatr.dia_cobranca, 'dd'), 'yyyy-mm-dd') AS dt_vencimento
           , c.data_ini
          INTO rC
          FROM competencia AS c
         WHERE periodicidade = 'Mensal'
           AND data_ini > rUltData

           and not((rMatr.seq_produto_classe=5) and (substr(c.competencia,1,2) in ('01','02')))
        ORDER BY c.data_ini
         LIMIT 1;

         INSERT INTO movimento_cobranca
           (matricula, seq_produto_taxa, valor_devido, valor_pago, data_vencimento, data_pagamento
           ,data_cancelamento, usuario_alteracao, data_alteracao, seq_pessoa, competencia)
        VALUES
           ( pmatricula,
           rMatr.seq_produto_taxa,
           rMatr.valor, --valor_devido,
           null, -- valor_pago,
           rC.dt_vencimento, --data_vencimento,
           null, -- data_pagamento,
           null, --data_cancelamento,
           -78, --usuario_alteracao,
           now(), --data_alteracao,
           rMatr.seq_pessoa,
           rC.competencia);

        SELECT rUltData + interval '1 month' INTO rUltData;

      END LOOP;

    END IF;
      raise notice 'Tem? %', rUltData;
    END IF;

  END LOOP;

  RETURN 'OK';
END;

$$;



pg_restore: creating FUNCTION "public.cobranca_adiciona_taxa(integer, integer)"
pg_restore: [archiver (db)] Error from TOC entry 1207; 1255 47395441 FUNCTION cobranca_adiciona_taxa(integer, integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "cobranca_adiciona_taxa" already exists with same argument types
    Command was: CREATE FUNCTION public.cobranca_adiciona_taxa(pmatricula integer, pseq_produto_taxa integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $$
declare
  rPT record;
  rC record;
  rQ record;
  rUltData date;
  rVenc date;
Begin

   select * into rPT
     from taxa as t
     join produto_taxa as pt using(seq_taxa)
    where seq_produto_taxa= pseq_produto_taxa;

   if coalesce(rPT.ciclico,false) then --Verifica qual data falta
      if rPT.periodicidade='Mensal' then

         select max(data_fim) into rUltData
           from movimento_cobranca as mc
           join competencia as c using(competencia)
           join produto_taxa as pt using(seq_produto_taxa)
          where seq_produto_taxa= pseq_produto_taxa;

         rUltData:=coalesce(rUltData,now());

         select * into rC
           from competencia as c
          where periodicidade=rPT.periodicidade
           and data_ini>rUltData
         order by c.data_ini
           limit 1;

         rVenc:=rC.data_ini;

        INSERT INTO movimento_cobranca(
             matricula, seq_produto_taxa, valor_devido,
            valor_pago, data_vencimento, data_pagamento, data_cancelamento,
            usuario_alteracao, data_alteracao, seq_pessoa, competencia)
         VALUES (
               pmatricula,
               pseq_produto_taxa,
               rPT.valor, --valor_devido,
               null, -- valor_pago,
               rVenc, --data_vencimento,
               null, -- data_pagamento,
               null, --data_cancelamento,
               -78, --usuario_alteracao,
               now(), --data_alteracao,
               (select seq_pessoa from matricula where matricula=pmatricula),
               rC.competencia);


      end if;


   end if;



   return 'OK';
end;

$$;



pg_restore: creating FUNCTION "public.competencia_atual()"
pg_restore: [archiver (db)] Error from TOC entry 1215; 1255 49625524 FUNCTION competencia_atual() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "competencia_atual" already exists with same argument types
    Command was: CREATE FUNCTION public.competencia_atual() RETURNS character varying
    LANGUAGE plpgsql
    AS $$

 declare

   lsCompetencia varchar;

begin

select competencia into lsCompetencia from competencia where data_ini<=now()::date and data_fim >= now()::date;


return lsCompetencia;


end;$$;



pg_restore: creating FUNCTION "public.concate(text, text)"
pg_restore: [archiver (db)] Error from TOC entry 1208; 1255 47395442 FUNCTION concate(text, text) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "concate" already exists with same argument types
    Command was: CREATE FUNCTION public.concate(text, text) RETURNS text
    LANGUAGE sql
    AS $_$
SELECT COALESCE($2 ||', '|| $1,$1,$2,NULL)
$_$;



pg_restore: creating FUNCTION "public.concatefinal(text)"
pg_restore: [archiver (db)] Error from TOC entry 1209; 1255 47395443 FUNCTION concatefinal(text) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "concatefinal" already exists with same argument types
    Command was: CREATE FUNCTION public.concatefinal(text) RETURNS text
    LANGUAGE sql
    AS $_$
SELECT substr($1,1,length($1))
$_$;



pg_restore: creating FUNCTION "public.depois_inserir_sessao()"
pg_restore: [archiver (db)] Error from TOC entry 1210; 1255 47395444 FUNCTION depois_inserir_sessao() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "depois_inserir_sessao" already exists with same argument types
    Command was: CREATE FUNCTION public.depois_inserir_sessao() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
declare
  rQ record;
begin
   for rQ in select *
               from evento_produto as ep
              where ep.seq_evento=new.seq_evento

                and not exists (select 1
                                  from sessao_evento_produto as ss1
                                  join evento_produto as ep1 using(seq_evento_produto)
                                 where ep1.seq_evento=new.seq_evento
                                   and ss1.seq_sessao = new.seq_sessao
                                   and ss1.seq_evento_produto = ep.seq_evento_produto) loop
       INSERT INTO sessao_evento_produto(
            seq_sessao, seq_evento_produto, qtde,
            dt_carga, seq_supervisor, usuario_alteracao, data_alteracao)
      VALUES (
            new.seq_sessao,
            rQ.seq_evento_produto,
            500,
            null, --dt_carga,
            null, --seq_supervisor,
            'Andre e Buddy', --usuario_alteracao,
            now()); --data_alteracao);

   end loop;

   return new;
end; $$;



pg_restore: creating FUNCTION "public.em_dia(integer, character varying)"
pg_restore: [archiver (db)] Error from TOC entry 1230; 1255 49629109 FUNCTION em_dia(integer, character varying) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "em_dia" already exists with same argument types
    Command was: CREATE FUNCTION public.em_dia(pimatricula integer, pscompetencia character varying) RETURNS boolean
    LANGUAGE plpgsql
    AS $$

 declare

   liqtde integer;

   lscompetencia varchar(10);

begin



if pscompetencia is null then

  lscompetencia := competencia_atual();

else

  lscompetencia := pscompetencia;

end if;


select count(seq_movimento_cobranca)

  into liqtde

from movimento_cobranca

where matricula = pimatricula

  and valor_pago is not null

  and competencia = lscompetencia;



  return liqtde > 0;




end;$$;



pg_restore: creating FUNCTION "public.estorna_movimento()"
pg_restore: [archiver (db)] Error from TOC entry 1211; 1255 47395445 FUNCTION estorna_movimento() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "estorna_movimento" already exists with same argument types
    Command was: CREATE FUNCTION public.estorna_movimento() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
declare
   rEventoProduto  record;
   rIngressoNumero record;
   vseq_ingresso   int4;
   ieven_ref       Integer;
begin
   -- se tiver data de estorno, gera o cancelamento dos ingressos gerados pela movimento_item --
   if new.data_estorno is not null then
      update ingresso set dt_cancelamento = new.data_estorno where seq_movimento_item in (select seq_movimento_item from movimento_item where seq_movimento = new.seq_movimento);
   end if;

   return new;
end; $$;



pg_restore: creating FUNCTION "public.fatura_retorno()"
pg_restore: [archiver (db)] Error from TOC entry 1212; 1255 47395446 FUNCTION fatura_retorno() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fatura_retorno" already exists with same argument types
    Command was: CREATE FUNCTION public.fatura_retorno() RETURNS integer
    LANGUAGE plpgsql
    AS $$

declare
  rRetorno  record;

  licont integer;
begin

  licont := 0;
  for rRetorno in (select *

                     from public.cobranca_retorno

                    where dt_lido_sistema is null

                    order by seq_cobranca_retorno) loop

     licont := licont + 1;

     if rRetorno.cod_ocorrencia = '06' then

       update public.cobranca_titulo

          set status = rRetorno.cod_ocorrencia,

              data_alteracao = now(),

              usuario_alteracao = 'fatura_retorno_pgto',

              valor_pago =  rRetorno.vlr_pago::numeric/100,

              data_pagamento = rRetorno.dt_credito

        where nosso_numero = rRetorno.nosso_numero;

      else

       update public.cobranca_titulo

          set status = rRetorno.cod_ocorrencia,

              data_alteracao = now(),

              usuario_alteracao = 'fatura_retorno'

        where nosso_numero = rRetorno.nosso_numero;

     end if;

     update public.cobranca_retorno set dt_lido_sistema = now() where seq_cobranca_retorno = rRetorno.seq_cobranca_retorno;

  end loop;

  return licont;
end;
$$;



pg_restore: creating FUNCTION "public.fnc_abertura_jogo(date)"
pg_restore: [archiver (db)] Error from TOC entry 1213; 1255 47395447 FUNCTION fnc_abertura_jogo(date) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_abertura_jogo" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_abertura_jogo(pdia date) RETURNS character varying
    LANGUAGE plpgsql
    AS $$
declare
 rQ record;
 i integer;
 vE integer;
 vCB varchar(200);
 vCP integer;
 vTem integer;
Begin

-- acesso historico
select seq_evento into vE from evento where dt_evento::date= (select min(data_acesso)::date from acesso);
insert into acesso_historico ( --seq_acesso_historico, codigo, status, data_acesso, usuario_alteracao,
      --seq_evento, seq_produto, seq_catraca, data_alteracao, tipo
SELECT nextval('acesso_historico_seq_acesso_historico_seq'), a.codigo, a.status, a.data_acesso, l.usuario_alteracao,
       vE, l.seq_produto, a.seq_catraca, a.data_alteracao, a.tipo, l.mensagem
  FROM acesso as a
  left join liberacao as l using(codigo)
 --where seq_acesso not in (SELECT seq_acesso_historico from acesso_historico)
);
delete from acesso;

insert into liberacao_historico (
SELECT nextval('seq_liberacao_historico'), seq_liberacao, codigo, seq_produto,
       status, data_acesso, usuario_alteracao, data_alteracao, tipo_acesso,
       mensagem, vE
  FROM liberacao
);
delete from liberacao;

--for rQ in Select * from socio_tmp loop
for rQ in select cod_barra as codigo
            from matricula as m
            join cartao as c using (matricula)
           where em_dia
           loop

select seq_liberacao into vTem from liberacao where codigo=rQ.codigo;

if vTem is null then

insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       rQ.codigo,
       8, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'DA', --status,
       null, --data_acesso,
       'Barata', --usuario_alteracao,
       now(), --data_alteracao,
       'socio', --tipo_acesso,
       'BEM VINDO' --mensagem
       );

end if;

end loop;

-- INGRESSOS --

for rQ in
select  nro_codigo_barras as codigo, p.seq_produto
  from movimento as m
  join movimento_item as mi using(seq_movimento)
  left join ingresso as i on (i.seq_movimento_item = mi.seq_movimento_item)
  join sessao_evento_produto as sep on (sep.seq_sessao_evento_produto = mi.seq_sessao_evento_produto)
  join evento_produto as ep on (ep.seq_evento_produto = sep.seq_evento_produto)
  join produto as p using(seq_produto)
  join evento as e on (e.seq_evento=ep.seq_evento)
  join usuario as u on (u.seq_usuario = m.operador)
where m.data_estorno is null
  and i.dt_cancelamento is null
  and e.dt_evento::date = pdia
  order by e.descricao, e.dt_evento, u.nome, p.produto
 loop

select seq_liberacao into vTem from liberacao where codigo=rQ.codigo;

if vTem is null then

insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       rQ.codigo,
       rQ.seq_produto, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'DA', --status,
       null, --data_acesso,
       'Barata', --usuario_alteracao,
       now(), --data_alteracao,
       'torcedor', --tipo_acesso,
       'BEM VINDO' --mensagem
       );
end if;
end loop;


delete from liberacao where codigo='0037000019042D';
insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       '0037000019042D',
       8, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'ME', --status,
       null, --data_acesso,
       'Vinicius', --usuario_alteracao,
       now(), --data_alteracao,
       'mestre', --tipo_acesso,
       'Mavetec' --mensagem
       );

delete from liberacao where codigo='0037000025760D';
insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       '0037000025760D',
       8, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'ME', --status,
       null, --data_acesso,
       'Vinicius', --usuario_alteracao,
       now(), --data_alteracao,
       'mestre', --tipo_acesso,
       'Mestre' --mensagem
       );


delete from liberacao where codigo='0037000019671D';
insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       '0037000019671D',
       8, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'ME', --status,
       null, --data_acesso,
       'Vinicius', --usuario_alteracao,
       now(), --data_alteracao,
       'mestre', --tipo_acesso,
       'Mestre' --mensagem
       );


delete from liberacao where codigo='0037000036559D';
insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       '0037000036559D',
       8, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'ME', --status,
       null, --data_acesso,
       'Vinicius', --usuario_alteracao,
       now(), --data_alteracao,
       'mestre', --tipo_acesso,
       'Mestre' --mensagem
       );



-- Baca Catraca le diferente
UPDATE liberacao set codigo=substr(codigo,2,19)||'D' where codigo ilike('1%');

return 'ECnh soh AS TOPs';
end;
$$;



pg_restore: creating FUNCTION "public.fnc_carrega_even_ref()"
pg_restore: [archiver (db)] Error from TOC entry 1214; 1255 47395448 FUNCTION fnc_carrega_even_ref() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_carrega_even_ref" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_carrega_even_ref() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
begin
   new.even_ref := (select max(coalesce(even_ref,0)) + 1 from evento);
   return new;
end; $$;



pg_restore: creating FUNCTION "public.fnc_cobranca_titulo()"
pg_restore: [archiver (db)] Error from TOC entry 1216; 1255 47395449 FUNCTION fnc_cobranca_titulo() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_cobranca_titulo" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_cobranca_titulo() RETURNS trigger
    LANGUAGE plpgsql
    AS $$

declare

  rItensPgto record;



begin


  if new.status = '06' then


    if new.valor_pago <> new.valor_total then

       new.status = 'Valor Dif';

    else

      if old.status = new.status then

         new.status = 'Duplicado';

      else

        for rItensPgto in (select *

                             from public.cobranca_titulo_item

                            where seq_cobranca_titulo = new.seq_cobranca_titulo) loop


          update public.movimento_cobranca

             set valor_pago = rItensPgto.valor,

                 data_pagamento = new.data_pagamento,

                 data_alteracao = now(),

                 usuario_alteracao = 'fatura_retorno_pgto'

           where seq_movimento_cobranca = rItensPgto.seq_movimento_cobranca;

        end loop;

      end if;

    end if;

  end if;

  return NEW;

end;$$;



pg_restore: creating FUNCTION "public.fnc_gera_boleto_carne(integer, integer)"
pg_restore: [archiver (db)] Error from TOC entry 1217; 1255 47395450 FUNCTION fnc_gera_boleto_carne(integer, integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_gera_boleto_carne" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_gera_boleto_carne(integer, integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $_$

declare
 pMovimento alias FOR $1;
 pRemessa   alias FOR $2;
 rNossoNumero character varying(8);
 sCobranca       integer;
 iMov            integer;
 dtVencimento       date;

 rM record;
 rQ record;

BEGIN

    -- Se ja gerou o movimento, só retorna o nosso_numero
    SELECT nosso_numero FROM cobranca_titulo INTO rNossoNumero WHERE seq_movimento = pMovimento;
    --raise notice '%',rNossoNumero;

    IF (rNossoNumero IS NULL) THEN

        SELECT seq_movimento
             , data_criacao
             , valor_total
             , usuario_alteracao
             , seq_pessoa
             , (SELECT COALESCE(MIN(data_vencimento), NOW()+'3 days') AS dt_vencimento
                  FROM movimento_cobranca
                 WHERE seq_movimento_cobranca IN (SELECT seq_movimento_cobranca
                                                    FROM movimento_item
                                                   WHERE seq_movimento = movimento.seq_movimento)) AS data_vencimento
          FROM movimento
          INTO rM
         WHERE seq_movimento = pMovimento
           AND data_pagamento IS NULL;

        IF (rM.seq_movimento IS NOT NULL) THEN

            dtVencimento := rM.data_vencimento;

            IF (dtVencimento <= NOW()) THEN
                dtVencimento := NOW() + '3 days';
            END IF;

            SELECT '1'||trim(to_char(nextval('seq_nosso_numero'),'0000000')) INTO rNossoNumero;

            SELECT nextval('cobranca_titulo_seq_cobranca_titulo_seq'::regclass) INTO sCobranca;

            INSERT INTO public.cobranca_titulo
                 (seq_cobranca_titulo, seq_cobranca_retorno, nosso_numero, titulo, status, valor_total
                 ,valor_pago, valor_desconto, mensagem, data_pagamento, usuario_alteracao, data_alteracao
                 ,seq_pessoa, seq_remessa, seq_movimento, dt_vencimento)
            VALUES
            ( sCobranca -- seq_cobranca_titulo
            , NULL -- seq_cobranca_retorno
            , rNossoNumero -- nosso_numero
            , NULL -- titulo
            , 'Bol' -- status
            , rM.valor_total -- valor_total
            , NULL -- valor_pago
            , NULL -- valor_desconto
            , '---' -- mensagem
            , NULL -- data_pagamento
            , rM.usuario_alteracao -- usuario_alteracao
            , NOW() -- data_alteracao
            , rM.seq_pessoa -- seq_pessoa
            , pRemessa -- seq_remessa
            , rM.seq_movimento -- seq_movimento
            , dtVencimento -- dt_vencimento
            );

            FOR rQ IN SELECT mi.seq_movimento_item
                           , mi.seq_produto_taxa
                           , mi.valor_devido
                           , mi.seq_movimento_cobranca
                           , mi.usuario_alteracao
                           , mi.data_alteracao
                           , mc.data_vencimento
                        FROM movimento_item AS mi
                        JOIN movimento_cobranca AS mc USING (seq_movimento_cobranca)
                        WHERE seq_movimento = pMovimento
            LOOP

                IF (pRemessa = -1) THEN
                    dtVencimento := NOW() + '3 days';
                ELSE
                    dtVencimento := rQ.data_vencimento;
                END IF;

                INSERT INTO public.cobranca_titulo_item
                    (seq_cobranca_titulo, valor, seq_movimento_cobranca, usuario_alteracao, data_alteracao)
                VALUES
                    ( sCobranca -- seq_cobranca_titulo
                    , rQ.valor_devido -- valor
                    , rQ.seq_movimento_cobranca -- seq_movimento_cobranca
                    , rQ.usuario_alteracao -- usuario_alteracao
                    , rQ.data_alteracao -- data_alteracao
                    );
            END LOOP;

        ELSE
            rNossoNumero := -1;
        END IF;

    END IF;

    RETURN rNossoNumero;

END;
$_$;



pg_restore: creating FUNCTION "public.fnc_insere_socios_tmp()"
pg_restore: [archiver (db)] Error from TOC entry 1218; 1255 47395451 FUNCTION fnc_insere_socios_tmp() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_insere_socios_tmp" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_insere_socios_tmp() RETURNS character varying
    LANGUAGE plpgsql
    AS $$
declare
 rQ record;
 i integer;
 vE integer;
 vCB varchar(200);
 vCP integer;
 vTem integer;
Begin

for rQ in Select * from socio_tmp loop

select seq_liberacao into vTem from liberacao where codigo=rQ.codigo;

if vTem is null then

insert into liberacao (codigo, seq_produto, status, data_acesso, usuario_alteracao,
       data_alteracao, tipo_acesso, mensagem)
  values (
       rQ.codigo,
       8, --case when rQ.nome ilike('%Cadeira%') then 12 else 13 end, --as  seq_produto,
       'EA', --status,
       null, --data_acesso,
       'Barata', --usuario_alteracao,
       now(), --data_alteracao,
       'socio', --tipo_acesso,
       'BEM VINDO' --mensagem
       );

end if;

end loop;

return 'Elias deu o cu pro Zico';
end;
$$;



pg_restore: creating FUNCTION "public.fnc_numero_ingresso(integer)"
pg_restore: [archiver (db)] Error from TOC entry 1219; 1255 47395452 FUNCTION fnc_numero_ingresso(integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_numero_ingresso" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_numero_ingresso(integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $_$

declare

   base alias for $1;

   vaux int8;
Begin

   vaux:=(base::text||trim(to_char(((random()*999)::int),'000')))::int8;
   vaux:=fnc_numero_valido(vaux);
   return '1'||trim(to_char(vaux,'0000000000000'));
end;


$_$;



pg_restore: creating FUNCTION "public.fnc_numero_valido(bigint)"
pg_restore: [archiver (db)] Error from TOC entry 1220; 1255 47395453 FUNCTION fnc_numero_valido(bigint) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "fnc_numero_valido" already exists with same argument types
    Command was: CREATE FUNCTION public.fnc_numero_valido(bigint) RETURNS character varying
    LANGUAGE plpgsql
    AS $_$

declare

   base alias for $1;

   d1 Integer;

   d4 Integer;

   xx Integer;

   nCount Integer;

   resto Integer;

   digito1 Integer;

   digito2  Integer;

   vCheck varchar;

   xCPF   varchar;

Begin

 xCPF:=base||'9';

 d1 := 0;

 d4 := 0;

 xx := 1;

 for nCount in  1..Length(xCPF)-1 loop

    if strPos( substr( xCPF, nCount, 1 ), '/-.' ) = 0 then

       d1 := d1 + ( 11 - xx ) * ( substr( xCPF, nCount, 1 ) )::integer;

    end if;

       d4 := d4 + ( 12 - xx ) * ( substr( xCPF, nCount, 1 ) )::integer;

       xx := xx+1;

  end loop;

  resto := mod(d1,11);

  if resto < 2 then

       digito1 := 0;

  else

      digito1 := 11 - resto;

  end if;

  d4 := d4 + 2 * digito1;

  resto := mod(d4,11);

  if resto < 2 then

      digito2 := 0;

  else

    digito2 := 11 - resto;

  end if;

    --Check := IntToStr(Digito1) + IntToStr(Digito2);


  vCheck :=(Digito2);


  return  (base)||vCheck;


end;


$_$;



pg_restore: creating FUNCTION "public.gera_ingressos_do_pagamento()"
pg_restore: [archiver (db)] Error from TOC entry 1221; 1255 47395454 FUNCTION gera_ingressos_do_pagamento() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "gera_ingressos_do_pagamento" already exists with same argument types
    Command was: CREATE FUNCTION public.gera_ingressos_do_pagamento() RETURNS trigger
    LANGUAGE plpgsql
    AS $$
declare
   rEventoProduto  record;
   rIngressoNumero record;
   vseq_ingresso   int4;
   ieven_ref       Integer;
   vcaixa          integer;
begin
select caixa into vcaixa from movimento where seq_movimento=new.seq_movimento;
if vcaixa is null then
   -- verifica se existe na tabela de ingresso, se n�o existe gera o insert. --
   if new.seq_movimento_item not in (select seq_movimento_item from ingresso) then
      -- pega o event_ref do evendo --
      ieven_ref := (select evento.even_ref
                    from sessao_evento_produto
                    join sessao on (sessao.seq_sessao = sessao_evento_produto.seq_sessao)
                    join evento on (evento.seq_evento = sessao.seq_evento)
                    where seq_sessao_evento_produto = new.seq_sessao_evento_produto);

      -- loop na quantidade do movimento item --
      for licont in 1..(new.qtde::integer) loop
              vseq_ingresso   := nextval('ingresso_seq_ingresso_seq');
              -- pega 1 numero da tabela ingresso_numero --
              select * into rIngressoNumero from ingresso_numero where even_ref = ieven_ref and not usado limit 1;

              -- gera o insert na tabela de ingresso --
              INSERT INTO ingresso(seq_ingresso,seq_sessao_evento_produto, seq_pessoa, seq_assento, nro_codigo_barras, nro_ingresso, nro_2d, nro_protocolo,
                                   seq_cartao, usuario_alteracao, data_alteracao, dt_cancelamento, seq_movimento_item)
                           VALUES (vseq_ingresso,
                                   new.seq_sessao_evento_produto,                                                           -- seq_sessao_evento_produto
                                  (select seq_pessoa from movimento where seq_movimento = new.seq_movimento),               -- seq_pessoa
                                  /* (select seq_assento from produto_assento where seq_produto = rEventoProduto.seq_produto), -- seq_assento */
                                  null,                                                                                     -- seq_assento
                                  rIngressoNumero.ingresso_numero,                                                          -- nro_codigo_barras
                                  rIngressoNumero.ingresso_numero,                                                          -- nro_ingresso
                                  null,                                                                                     -- nro_2d
                                  null,                                                                                     -- nro_protocolo
                                  null,                                                                                     -- seq_cartao
                                  new.usuario_alteracao,                                                                    -- usuario_alteracao
                                  now(),                                                                                    -- data_alteracao
                                  null,                                                                                     -- dt_cancelamento
                                  new.seq_movimento_item);                                                                  -- seq_movimento_item

              -- marca o numero selecionado como usado --
              update ingresso_numero set usado = true where ingresso_numero = rIngressoNumero.ingresso_numero;
      end loop;
   end if;
end if;
   return new;
end; $$;



pg_restore: creating FUNCTION "public.gera_script_importacao(text)"
pg_restore: [archiver (db)] Error from TOC entry 1222; 1255 47395455 FUNCTION gera_script_importacao(text) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "gera_script_importacao" already exists with same argument types
    Command was: CREATE FUNCTION public.gera_script_importacao(ptabela text) RETURNS text
    LANGUAGE plpgsql
    AS $$

declare

 vSQL text;

 rT record;

 rC record;

 vCampos text;

 vValores text;

BEGIN


 vCampos :='';

 vValores :='';

 vSQL:='';

  for rC in SELECT *

                          FROM information_schema.columns

                         WHERE table_name = ptabela

                           AND table_schema = 'migra'

                      order by column_name

  loop


   vCampos:=vCampos||rC.column_name||',';

   vValores:=vValores||'''||coalesce(''''''''||replace('||rC.column_name||','''''''','''')||'''''''',''null'')||'',';



/*


select substr('1234567',1, length('1234567')-1)


SELECT *

                          FROM information_schema.columns

                         WHERE table_name = 'ger_pessoa'

                           AND table_schema = 'migra'

                      order by column_name

  SELECT

    pg_attribute.attname,

    format_type(pg_attribute.atttypid, pg_attribute.atttypmod)

  into rCampoChave

  FROM pg_index, pg_class, pg_attribute

  WHERE pg_class.oid = (TG_TABLE_SCHEMA||'.'||TG_RELNAME)::regclass

    AND pg_attribute.attname = rColunasTabela.column_name

    AND indrelid = pg_class.oid

    AND pg_attribute.attrelid = pg_class.oid

    AND pg_attribute.attnum = any(pg_index.indkey)

    AND indisprimary;

*/




  end loop;


vCampos:= substr(vCampos,1, length(vCampos)-1);

vValores:= substr(vValores,1, length(vValores)-1);


vSQL:='select ''insert into migra.'||ptabela||' ('||vCampos||') values ('||vValores||');'' as isso from '||ptabela;



return vSQL;

END;

$$;



pg_restore: creating FUNCTION "public.insere_arvore(bigint, character varying, character varying, character varying)"
pg_restore: [archiver (db)] Error from TOC entry 1223; 1255 47395456 FUNCTION insere_arvore(bigint, character varying, character varying, character varying) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "insere_arvore" already exists with same argument types
    Command was: CREATE FUNCTION public.insere_arvore(bigint, character varying, character varying, character varying) RETURNS integer
    LANGUAGE plpgsql SECURITY DEFINER
    AS $_$
declare
  vseq_pai alias for $1;
  vnome alias for $2;
  vusuario alias for $3;
  vtabela alias for $4;
  vmaior int4;
  vesq int4;
  vdir int4;
  vdir_novo int4;
  vesq_novo int4;
  vnivel int4;
  vnova_seq int4;
  vsql text;
  vquem text;
  qaux record;
  vcaminho text;
  qcaminho record;

begin
  vsql := ' select max(dir) as maior from '||vtabela;
  vquem :=current_user;
  raise notice '%,como %',vsql, vquem ;
  for qaux in execute vsql loop
    vmaior:=qaux.maior;
  end loop;
  vsql := 'select esq,dir  from '||vtabela||' where seq_'||vtabela||' ='||vseq_pai::text;
  raise notice '%',vsql;
  for qaux in execute vsql loop
    vesq:=qaux.esq;
    vdir:=qaux.dir;
  end loop;
  vsql := 'select count(*) as nivel from '||vtabela||' where '||vesq::text||' BETWEEN esq AND dir';
  raise notice '%',vsql;
  for qaux in execute vsql loop
    vnivel:=qaux.nivel;
  end loop;

  vdir_novo:=vdir+1;
  vesq_novo:=vdir;

  vsql := 'update '||vtabela||' set esq=esq+2, dir=dir+2 where esq > '||vesq_novo::text; --Todos do outros ramos a direita
  execute vsql;

  vsql := 'update '||vtabela||' set dir=dir+2 where '||vesq_novo::text||' BETWEEN esq AND dir'; --Todos do mesmo ramos
  execute vsql;

  select nextval('seq_'||vtabela) into vnova_seq ;

  vsql := 'select * from '||vtabela||' where esq <= '||vdir::text||'  and dir >= '||vdir_novo::text||' order by nivel';
  vcaminho:='';
  for qcaminho in execute vsql loop
      vcaminho:=vcaminho||qcaminho.nome||' -> ';
  end loop;
  vcaminho:=vcaminho||vnome;

  vsql:='Insert into '||vtabela||' (
                 seq_'||vtabela||',
                 esq,
                 nome,
                 data_geracao,
                 usuario_alteracao,
                 dir,
                 nivel,
                 caminho,
                 '||vtabela||'_pai
         )
  Values (
         '||vnova_seq::text||',
         '||vdir::text||', '||--:esq,
         ''''||vnome||''', '||--:dica_classe,
         'now(), '||--:data_geracao,
         ''''||vusuario||''', '||--:usuario_alteracao,
         vdir_novo::text||', '||--:dir,
         vnivel::text||', '|| --:nivel
         ''''||vcaminho||''', '||
         vseq_pai::text||') ';
  raise notice '%',vsql;
  execute vsql;


  return vnova_seq;
end;
$_$;



pg_restore: creating FUNCTION "public.insere_pagamentos_carga_inicial()"
pg_restore: [archiver (db)] Error from TOC entry 1224; 1255 47395457 FUNCTION insere_pagamentos_carga_inicial() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "insere_pagamentos_carga_inicial" already exists with same argument types
    Command was: CREATE FUNCTION public.insere_pagamentos_carga_inicial() RETURNS character varying
    LANGUAGE plpgsql
    AS $$

declare

    rQ record;
    vQuantas integer;
    i integer;
    vSeq_produto_taxa integer;
    vValor numeric(20,5);
    rComp record;
    rTem record;
Begin
  for rQ in select im.nome, p.nome,m.matricula as matboa,*
              from tmp_importacao_socio  as im
              left join matricula as m on (replace(im.matricula,'.','')::integer=m.matricula)
              left join pessoa as p on (m.seq_pessoa=p.seq_pessoa)
            loop

  vQuantas:=extract(month from now());
  if (length(rQ.ult_pagamento)=7 and rQ.ult_pagamento ilike('2013%')) then
     vQuantas:=extract(month from to_date(rQ.ult_pagamento,'yyyy/mm'));
  end if;


  for i in 1..vQuantas loop

      select * into rComp from competencia where competencia=trim(to_char(i,'00'))||'13' and periodicidade='Mensal';
      if rComp.competencia is null then
         raise exception 'Nao achou competencia % %',i,rQ.ult_pagamento;
      end if;


      if rQ.categoria='ECNH SOCIO' then
         vSeq_produto_taxa:=1;
         vValor:=30.0;
      end if;

      if rQ.categoria='ECNH CONS ' then
         vSeq_produto_taxa:=3;
         vValor:=100.0;
      end if;

      if rQ.categoria='ECNH ESCO ' then
         vSeq_produto_taxa:=4;
         vValor:=50.0;
      end if;


      select *
        into rTem
        from movimento_cobranca
       where matricula=rQ.matboa
         and seq_produto_taxa=vSeq_produto_taxa
         and competencia=rComp.competencia;

      if rTem.matricula is null then
          INSERT INTO movimento_cobranca(
             matricula, seq_produto_taxa, valor_devido,
             valor_pago, data_vencimento, data_pagamento, data_cancelamento,
             usuario_alteracao, data_alteracao, seq_pessoa, competencia)
        VALUES (
             rQ.matboa, --matricula,
             vSeq_produto_taxa,
             vValor, --valor_devido,
             vValor, --valor_pago,
             rComp.data_ini, -- data_vencimento,
             rComp.data_ini, --data_pagamento,
             null, --data_cancelamento,
             -94434324, --usuario_alteracao,
             now(), --data_alteracao,
             rQ.seq_pessoa,
             rComp.competencia);
     end if;


  end loop;


  end loop;

 return 'Vinicius Daocueba' ;
end;


$$;



pg_restore: creating FUNCTION "public.popula_ingresso_numero(integer, integer)"
pg_restore: [archiver (db)] Error from TOC entry 1225; 1255 47395458 FUNCTION popula_ingresso_numero(integer, integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "popula_ingresso_numero" already exists with same argument types
    Command was: CREATE FUNCTION public.popula_ingresso_numero(pnum_eventos integer, pnum_ingressos_evento integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $$

declare

  i  integer;
  j  integer;
  vult_evento integer;
  vSeq int;
  vCB int8;
  vevento  integer;
  vmax_base int8;
  vmin_base int8;
  rEsse int8;
  rR int8;

Begin

  select max(even_ref)+1 into vult_evento  from ingresso_numero;
  vult_evento:=coalesce(vult_evento,1);
  for i in vult_evento..(pnum_eventos+vult_evento)-1 loop
     raise notice 'Gerando evento %',i;
     for j in 1..pnum_ingressos_evento loop
        vSeq:=nextval('seq_ingresso_numero');
        vCB := fnc_numero_ingresso(vSeq)::int8;
        vevento:=(random()*pnum_eventos+vult_evento)::int ;
         --raise notice 'inserindo evento %',vevento;

        INSERT INTO ingresso_numero(
            ingresso_numero, usado, even_ref, seq)
         VALUES (
             vCB, --ingresso_numero,
             false, --usado,
             vevento,
             vSeq); --even_ref);


     end loop;

  end loop;

  update ingresso_numero set even_ref=vult_evento where even_ref=(pnum_eventos+vult_evento);

/*

 -- randomiza eventos
  select max(seq), min(seq)
    into vmax_base , vmin_base
    from ingresso_numero
   where even_ref>= vult_evento
    and even_ref<= (pnum_eventos+vult_evento)-1;

  for i in vult_evento..(pnum_eventos+vult_evento)-1 loop
     raise notice 'randomizando evento %',i;
     for j in 1..pnum_ingressos_evento loop
         rR:= vmin_base+ (random()* (vmax_base-vmin_base))::int8;
       select max( ingresso_numero) into rEsse
        from ingresso_numero
       where even_ref>= vult_evento
         and even_ref<= (pnum_eventos+vult_evento)-1
         and seq<=rR
         and not usado;

  --      raise notice '% % %', rR,i,j;
        update  ingresso_numero set even_ref=i, usado=true where  ingresso_numero= rEsse;

     end loop;

  end loop;

  update ingresso_numero
    set usado=false
   where even_ref>= vult_evento
    and even_ref<= (pnum_eventos+vult_evento)-1;

*/

return 'Elvis pegou o Baiano';

end;


$$;



pg_restore: creating FUNCTION "public.proxima_matricula()"
pg_restore: [archiver (db)] Error from TOC entry 1226; 1255 47395459 FUNCTION proxima_matricula() postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "proxima_matricula" already exists with same argument types
    Command was: CREATE FUNCTION public.proxima_matricula() RETURNS integer
    LANGUAGE plpgsql
    AS $$

declare

  vessa integer;

Begin
  select max(matricula) into vessa from matricula where matricula< 90000000;

  vessa:= (substr(vessa::text,1,5))::integer;
  vessa:=((vessa+1)::text||'00')::integer;

  return  vessa;


end;


$$;



pg_restore: creating FUNCTION "public.proxima_matricula(integer)"
pg_restore: [archiver (db)] Error from TOC entry 1227; 1255 47395460 FUNCTION proxima_matricula(integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "proxima_matricula" already exists with same argument types
    Command was: CREATE FUNCTION public.proxima_matricula(pseq_pessoa integer) RETURNS integer
    LANGUAGE plpgsql
    AS $$

declare

  vessa integer;
  vquantas integer;
  vnova integer;
  vposmat integer;

Begin

  select count(*),
         (substr(trim( to_char(matricula,'00000000')),1,6))::integer as mat,
         max((substr(trim( to_char(matricula,'00000000')),7,2))::integer) as posmat
    into vquantas,vessa,vposmat
    from matricula
   where seq_pessoa=pseq_pessoa group by mat;

  raise notice '-->%', vessa;
  if coalesce(vposmat,0) >=10 then
     vessa:=null;
  end if;
  if vessa is null then
    select max(matricula) into vessa from matricula where matricula< 90000000;
    vessa:= (substr(vessa::text,1,5))::integer;
    vnova:=((vessa+1)::text||'00')::integer;
  else
    -- select trim(to_char(1,'00'))
    vnova:=vessa::text||trim(to_char((vposmat+1),'00'));

  end if;

  return  vnova;


end;


$$;



pg_restore: creating FUNCTION "public.remessa_boleto_arquivo(integer)"
pg_restore: [archiver (db)] Error from TOC entry 1228; 1255 47395461 FUNCTION remessa_boleto_arquivo(integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "remessa_boleto_arquivo" already exists with same argument types
    Command was: CREATE FUNCTION public.remessa_boleto_arquivo(vseq_remessa integer) RETURNS text
    LANGUAGE plpgsql
    AS $_$
declare
  R text;
  rRemessa record;
  rI record;
  i integer;
begin
  i:=0;
  select * into rRemessa from remessa where seq_remessa=vseq_remessa;
-- HEADER
  R:='01REMESSA01COBRANCA       00000000000004251900ESPORTE CLUBE NOVO HAMBURGO   237BRADESCO       ';
  R:=R||to_char(now(),'DDMMYY')||'        MX'||trim(to_char(rRemessa.sequencia,'0000000'));
  R:=R||'                                                                                                                                                                                                                                                                                     000001';
  R:=R||chr(10);


-- DADOS
/*
alter table remessa_item add seq_movimento_cobranca integer;

ALTER TABLE pessoa
  ADD COLUMN cnpj character varying(50);
ALTER TABLE pessoa
  ADD COLUMN juridica boolean DEFAULT false;


*/

for rI in select ria.*, p.*
             from remessa_item as ria
             join movimento_cobranca as mc on ria.seq_movimento_cobranca=mc.seq_movimento_cobranca
             join pessoa as p on mc.seq_pessoa=p.seq_pessoa
            where ria.seq_remessa=vseq_remessa
              and  mc.data_pagamento is null
                --ri.data_vencimento <= rRemessa.data_vencimento
            loop
    i:=i+1;
    --  R:=R||'1 00000 0 00000 0000000 0 00090315201236660';
    --
    R:=R||'1';-- 001 a 001 Identifica��o do Registro 001
    R:=R||'00000';-- 002 a 006 Ag�ncia de D�bito 005
    R:=R||'0';-- 007 a 007 D�gito da Ag�ncia de D�bito 001
    R:=R||'00000';-- 008 a 012 Raz�o da Conta Corrente 005
    R:=R||'0000000';-- 013 a 019 Conta Corrente 007
    R:=R||'0';-- 020 a 020 D�gito da Conta Corrente 001
    R:=R||'00090315201236660';-- 021 a 037 Identifica��o da Empresa Cedente no Banco 017
    R:=R||trim(to_char(rI.seq_movimento_cobranca,'0000000000000000000000000'));-- 038 a 062 N� Controle do Participante 025
    R:=R||'00';-- 063 a 065 C�digo do Banco a ser debitado na C�mara de Compensa��o 003
    R:=R||'0';-- 066 a 066 Campo de Multa 001
    R:=R||'0000';-- 067 a 070 Percentual de multa 004
    R:=R||'00000000000';-- 071 a 081 Identifica��o do T�tulo no Banco 11
    R:=R||'0';-- 082 a 082 Digito de Auto Conferencia do Nosso N�mero 001
    R:=R||'0000000000';-- 083 a 092 Desconto Bonifica��o por dia 010
    R:=R||'1';-- 093 a 093 Condi��o para Emiss�o da Papeleta de Cobran�a 001
    R:=R||'N';-- 094 a 094 Ident. se emite papeleta para D�bito Autom�tico 001
    R:=R||'          ';-- 095 a 104 Identifica��o da Opera��o do Banco 010
    R:=R||' ';-- 105 a 105 Indicador Rateio Cr�dito 001
    R:=R||'2';-- 106 a 106 Endere�amento para Aviso do D�bito Autom�tico em Conta Corrente 001
    R:=R||'  ';-- 107 a 108 Branco 002
    R:=R||'01';-- 109 a 110 Identifica��o ocorr�ncia 002
    R:=R||trim(to_char(rI.seq_remessa_item,'0000000000'));-- 111 a 120 N� do Documento 010
    R:=R||to_char(rI.data_vencimento,'DDMMYY') ;-- 121 a 126 Data do Vencimento do T�tulo 006
    R:=R||replace(trim(to_char(rI.valor_vencimento,'00000000000.00')),'.','');-- 127 a 139 Valor do T�tulo 013
    R:=R||'000';-- 140 a 142 Banco Encarregado da Cobran�a 003
    R:=R||'00000';-- 143 a 147 Ag�ncia Deposit�ria 005
    R:=R||'01';-- 148 a 149 Esp�cie de T�tulo 002
    R:=R||'N';-- 150 a 150 Identifica��o 001
    R:=R||to_char(now(),'DDMMYY');-- 151 a 156 Data da emiss�o do T�tulo 006
    R:=R||'00';-- 157 a 158 1� instru��o 002
    R:=R||'00';-- 159 a 160 2� instru��o 002
    R:=R||'0000000000000';-- 161 a 173 Valor a ser cobrado por Dia de Atraso 013
    R:=R||'000000';-- 174 a 179 Data Limite P/Concess�o de Desconto 006
    R:=R||'0000000000000';-- 180 a 192 Valor do Desconto 013
    R:=R||'0000000000000';-- 193 a 205 Valor do IOF 013
    R:=R||'             ';-- 206 a 218 Valor do Abatimento a ser concedido ou cancelado 013

    if  rI.juridica then
       R:=R||'02';-- 219 a 220 Identifica��o do Tipo de Inscri��o do Sacado 002
       R:=R||lpad(rI.cnpj,14,'0');-- 221 a 234 N� Inscri��o do Sacado 014
    else
       R:=R||'01';-- 219 a 220 Identifica��o do Tipo de Inscri��o do Sacado 002
       R:=R||lpad(rI.cpf,14,'0');-- 221 a 234 N� Inscri��o do Sacado 014
    end if;
    R:=R||rpad(rI.nome,40,' ');-- 235 a 274 Nome do Sacado 040
    R:=R||rpad(replace(upper(trim(rI.endereco)||' '||trim(rI.numero)||coalesce(' '||trim(rI.complemento),'')),'RUA','R'),40,' ');-- 275 a 314 Endere�o Completo 040
    R:=R||'            ';-- 315 a 326 1� Mensagem 012
    R:=R||lpad(rI.cep,5,'0');-- 327 a 331 CEP 005
    R:=R||lpad(substr(rI.cep,6,3),3,'0');-- 332 a 334 Sufixo do CEP 003
    R:=R||rpad('',60,' ');-- 335 a 394 Sacador/Avalista ou 2� Mensagem 060
    R:=R||lpad(i::text,6,'0');-- 395 a 400 N� Seq�encial do Registro 006
    R:=R||chr(10);

---- SEGUNDA LINHA INFORMACOES

   i:=i+1;
   R:=R||'2';-- 001 a 001 Tipo Registro 001
   R:=R||rpad('Despesas: R$ '||replace(trim(to_char(35.50,'90.00')),'.',','),80,' ');-- 002 a 081 Mensagem 1 080
   R:=R||rpad('APOS VENC. PGTO SOMENTE NA SECRETARIA DO CLUBE',80,' ');-- 082 a 161 Mensagem 2 080
   R:=R||rpad('',80,' ');-- 162 a 241 Mensagem 3 080
   R:=R||rpad('',80,' ');-- 242 a 321 Mensagem 4 080
   R:=R||rpad('',45,' ');-- 322 a 366 Reserva 045 filler
   R:=R||'009';-- 367 a 369 Carteira 003
   R:=R||'03152';-- 370 a 374 Ag�ncia 005
   R:=R||'0123666';-- 375 a 381 Conta Corrente 007
   R:=R||'0';-- 382 a 382 D�gito C/C 001
   R:=R||'00000000000';-- 383 a 393 Nosso N�mero 011
   R:=R||'0';-- 394 a 394 DAC Nosso N�mero 001
   R:=R||lpad(i::text,6,'0');-- 395 a 400 N� Seq�encial de Registro 006


  end loop;
return R;
end;$_$;



pg_restore: creating FUNCTION "public.remessa_criacao(integer)"
pg_restore: [archiver (db)] Error from TOC entry 1229; 1255 47395463 FUNCTION remessa_criacao(integer) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "remessa_criacao" already exists with same argument types
    Command was: CREATE FUNCTION public.remessa_criacao(pseq_remessa integer) RETURNS character varying
    LANGUAGE plpgsql
    AS $$
declare
  rQ record;
  rR record;
  vSeqTitulo integer;
  vSeqTituloItem integer;
  vSeqPessoaAnt integer;
  vTotal numeric(30,5);
Begin

select *
  into rQ
  from remessa
 where seq_remessa=pseq_remessa;

delete from cobranca_titulo where seq_cobranca_titulo in ( select seq_cobranca_titulo from cobranca_titulo  where seq_remessa=pseq_remessa);
delete from cobranca_titulo where seq_remessa=pseq_remessa;


/*

alter table cobranca_titulo add seq_pessoa integer;
alter table cobranca_titulo add  seq_remessa integer;

ALTER TABLE cobranca_titulo
  DROP CONSTRAINT cobranca_cobranca_titulo_fk;
ALTER TABLE cobranca_titulo
  DROP CONSTRAINT cobranca_retorno_cobranca_titulo_fk;
ALTER TABLE cobranca_titulo
  ADD CONSTRAINT cobranca_cobranca_titulo_fk FOREIGN KEY (seq_cobranca)
      REFERENCES cobranca (seq_cobranca) MATCH SIMPLE
      ON UPDATE CASCADE ON DELETE NO ACTION;
ALTER TABLE cobranca_titulo
  ADD CONSTRAINT cobranca_retorno_cobranca_titulo_fk FOREIGN KEY (seq_cobranca_retorno)
      REFERENCES cobranca_retorno (seq_cobranca_retorno) MATCH SIMPLE
      ON UPDATE CASCADE ON DELETE NO ACTION;
ALTER TABLE cobranca_titulo  DROP COLUMN seq_cobranca;

ALTER TABLE cobranca_titulo
  ADD CONSTRAINT remessa_cobranca_titulo_fk FOREIGN KEY (seq_remessa)
      REFERENCES remessa (seq_remessa) MATCH SIMPLE
      ON UPDATE CASCADE ON DELETE NO ACTION;

ALTER TABLE cobranca_titulo
   ALTER COLUMN seq_cobranca_retorno DROP NOT NULL;

*/

vTotal:=0;
vSeqPessoaAnt:=-9;
for rQ in select *
            from movimento_cobranca  as mc
           where data_vencimento<=rQ.data_vencimento
             and data_pagamento is null
            order by seq_pessoa, matricula loop
   if vSeqPessoaAnt <> rQ.seq_pessoa then

      if vSeqPessoaAnt>0 then
         update cobranca_titulo set valor_total=vTotal where seq_titulo=vSeqTitulo;
         vTotal:=0;
      end if;

      vSeqTitulo := nextval('cobranca_titulo_seq_cobranca_titulo_seq');
      INSERT INTO cobranca_titulo(
            seq_cobranca_titulo, seq_remessa, seq_cobranca_retorno, nosso_numero,
            titulo, status, valor_total, valor_pago, valor_desconto, mensagem,
            data_pagamento, usuario_alteracao, data_alteracao, seq_pessoa)
       VALUES (
        vSeqTitulo, --seq_cobranca_titulo,
        pseq_remessa,
        null, --seq_cobranca_retorno,
        null, -- nosso_numero,
        null, --titulo,
        'Novo', --status,
        null, --valor_total,
        null, -- valor_pago,
        null, --valor_desconto,
        null, -- mensagem,
        null, --    data_pagamento,
        null, -- usuario_alteracao,
        now(), --data_alteracao,
        rQ.seq_pessoa);

   end if;

   INSERT INTO cobranca_titulo_item(
             seq_cobranca_titulo, valor, seq_movimento_cobranca,
            usuario_alteracao, data_alteracao)
    VALUES (

             vSeqTitulo, --seq_cobranca_titulo,
             rQ.valor_devido, -- valor,
             rQ.seq_movimento_cobranca,
             -899, --usuario_alteracao,
             now()); --data_alteracao);

    vTotal:=vTotal+ rQ.valor_devido;


 end loop;



   return 'OK';
end;

$$;



pg_restore: creating AGGREGATE "public.concatenex(text)"
pg_restore: [archiver (db)] Error from TOC entry 3727; 1255 47395464 AGGREGATE concatenex(text) postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  function "concatenex" already exists with same argument types
    Command was: CREATE AGGREGATE public.concatenex(text) (
    SFUNC = public.concate,
    STYPE = text,
    FINALFUNC = public.concatefinal
);



pg_restore: creating TABLE "public.acesso"
pg_restore: [archiver (db)] Error from TOC entry 1041; 1259 47400346 TABLE acesso postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso" already exists
    Command was: CREATE TABLE public.acesso (
    seq_acesso integer NOT NULL,
    codigo character varying(100) NOT NULL,
    status character varying(5) NOT NULL,
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    seq_catraca integer,
    tipo character varying(20)
);



pg_restore: creating TABLE "public.acesso_historico"
pg_restore: [archiver (db)] Error from TOC entry 1042; 1259 47400350 TABLE acesso_historico postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso_historico" already exists
    Command was: CREATE TABLE public.acesso_historico (
    seq_acesso_historico integer NOT NULL,
    codigo character varying(100) NOT NULL,
    status character varying(5) NOT NULL,
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    seq_evento integer,
    seq_produto integer,
    seq_catraca integer,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    tipo character varying(20),
    mensegem text
);



pg_restore: creating SEQUENCE "public.acesso_historico_seq_acesso_historico_seq"
pg_restore: [archiver (db)] Error from TOC entry 1043; 1259 47400357 SEQUENCE acesso_historico_seq_acesso_historico_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso_historico_seq_acesso_historico_seq" already exists
    Command was: CREATE SEQUENCE public.acesso_historico_seq_acesso_historico_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.acesso_historico_seq_acesso_historico_seq"
pg_restore: creating SEQUENCE "public.acesso_seq_acesso_seq"
pg_restore: [archiver (db)] Error from TOC entry 1044; 1259 47400359 SEQUENCE acesso_seq_acesso_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso_seq_acesso_seq" already exists
    Command was: CREATE SEQUENCE public.acesso_seq_acesso_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.acesso_seq_acesso_seq"
pg_restore: creating TABLE "public.assento"
pg_restore: [archiver (db)] Error from TOC entry 1045; 1259 47400361 TABLE assento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "assento" already exists
    Command was: CREATE TABLE public.assento (
    seq_assento integer NOT NULL,
    seq_setor integer NOT NULL,
    fila_numero character varying(100),
    coordenada_x numeric(30,5),
    coordenada_y numeric(30,5),
    coordenada_z numeric(30,5),
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.assento_seq_assento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1046; 1259 47400366 SEQUENCE assento_seq_assento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "assento_seq_assento_seq" already exists
    Command was: CREATE SEQUENCE public.assento_seq_assento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.assento_seq_assento_seq"
pg_restore: creating TABLE "public.baixa"
pg_restore: [archiver (db)] Error from TOC entry 1047; 1259 47400368 TABLE baixa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "baixa" already exists
    Command was: CREATE TABLE public.baixa (
    seq_baixa integer NOT NULL,
    dt_importacao timestamp without time zone,
    qtd_registros bigint,
    arquivo character varying
);



pg_restore: creating SEQUENCE "public.baixa_seq_baixa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1048; 1259 47400374 SEQUENCE baixa_seq_baixa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "baixa_seq_baixa_seq" already exists
    Command was: CREATE SEQUENCE public.baixa_seq_baixa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.baixa_seq_baixa_seq"
pg_restore: creating TABLE "public.bilheteria"
pg_restore: [archiver (db)] Error from TOC entry 1049; 1259 47400376 TABLE bilheteria postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "bilheteria" already exists
    Command was: CREATE TABLE public.bilheteria (
    seq_bilheteria integer NOT NULL,
    nome character varying(100) NOT NULL,
    local character varying,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    seq_evento_local integer
);



pg_restore: creating SEQUENCE "public.bilheteria_seq_bilheteria_seq"
pg_restore: [archiver (db)] Error from TOC entry 1050; 1259 47400383 SEQUENCE bilheteria_seq_bilheteria_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "bilheteria_seq_bilheteria_seq" already exists
    Command was: CREATE SEQUENCE public.bilheteria_seq_bilheteria_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.bilheteria_seq_bilheteria_seq"
pg_restore: creating TABLE "public.boleto_macro"
pg_restore: [archiver (db)] Error from TOC entry 1051; 1259 47400385 TABLE boleto_macro postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "boleto_macro" already exists
    Command was: CREATE TABLE public.boleto_macro (
    seq_boleto_macro integer NOT NULL,
    matricula integer,
    competencia character varying(50),
    gerado boolean
);



pg_restore: creating SEQUENCE "public.boleto_macro_seq_boleto_macro_seq"
pg_restore: [archiver (db)] Error from TOC entry 1052; 1259 47400388 SEQUENCE boleto_macro_seq_boleto_macro_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "boleto_macro_seq_boleto_macro_seq" already exists
    Command was: CREATE SEQUENCE public.boleto_macro_seq_boleto_macro_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.boleto_macro_seq_boleto_macro_seq"
pg_restore: creating TABLE "public.cadeira"
pg_restore: [archiver (db)] Error from TOC entry 1053; 1259 47400390 TABLE cadeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cadeira" already exists
    Command was: CREATE TABLE public.cadeira (
    seq_cadeira integer NOT NULL,
    cadeira character varying(50),
    x integer,
    y integer,
    z integer,
    status character varying(50),
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.cadeira_seq_cadeira_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1054; 1259 47400397 SEQUENCE cadeira_seq_cadeira_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cadeira_seq_cadeira_seq_1" already exists
    Command was: CREATE SEQUENCE public.cadeira_seq_cadeira_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cadeira_seq_cadeira_seq_1"
pg_restore: creating TABLE "public.camarote"
pg_restore: [archiver (db)] Error from TOC entry 1055; 1259 47400399 TABLE camarote postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "camarote" already exists
    Command was: CREATE TABLE public.camarote (
    seq_camarote integer NOT NULL,
    nome character varying(200),
    quantidade_cadeiras integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.camarote_seq_camarote_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1056; 1259 47400403 SEQUENCE camarote_seq_camarote_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "camarote_seq_camarote_seq_1" already exists
    Command was: CREATE SEQUENCE public.camarote_seq_camarote_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.camarote_seq_camarote_seq_1"
pg_restore: creating SEQUENCE "public.seq_cartao2"
pg_restore: [archiver (db)] Error from TOC entry 1057; 1259 47400405 SEQUENCE seq_cartao2 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_cartao2" already exists
    Command was: CREATE SEQUENCE public.seq_cartao2
    START WITH 2300
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.cartao"
pg_restore: [archiver (db)] Error from TOC entry 1058; 1259 47400407 TABLE cartao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cartao" already exists
    Command was: CREATE TABLE public.cartao (
    seq_cartao integer DEFAULT nextval('public.seq_cartao2'::regclass) NOT NULL,
    matricula integer NOT NULL,
    chip character varying(100),
    data_cancelamento timestamp without time zone,
    data_sincronia timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    cod_barra character varying(50)
);



pg_restore: creating TABLE "public.catraca"
pg_restore: [archiver (db)] Error from TOC entry 1059; 1259 47400412 TABLE catraca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "catraca" already exists
    Command was: CREATE TABLE public.catraca (
    seq_catraca integer NOT NULL,
    seq_portao integer,
    catraca character varying(100) NOT NULL,
    ip character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    nro_catraca integer
);



pg_restore: creating SEQUENCE "public.catraca_seq_catraca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1060; 1259 47400416 SEQUENCE catraca_seq_catraca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "catraca_seq_catraca_seq" already exists
    Command was: CREATE SEQUENCE public.catraca_seq_catraca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.catraca_seq_catraca_seq"
pg_restore: creating TABLE "public.ci_sessions"
pg_restore: [archiver (db)] Error from TOC entry 1061; 1259 47400418 TABLE ci_sessions postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ci_sessions" already exists
    Command was: CREATE TABLE public.ci_sessions (
    session_id character varying(40) DEFAULT '0'::character varying NOT NULL,
    ip_address character varying(45) DEFAULT '0'::character varying NOT NULL,
    user_agent character varying(120) NOT NULL,
    last_activity integer DEFAULT 0 NOT NULL,
    user_data text NOT NULL
);



pg_restore: creating TABLE "public.clube"
pg_restore: [archiver (db)] Error from TOC entry 1062; 1259 47400427 TABLE clube postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "clube" already exists
    Command was: CREATE TABLE public.clube (
    seq_clube integer NOT NULL,
    nome character varying(100) NOT NULL,
    logo character varying(255),
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.clube_seq_clube_seq"
pg_restore: [archiver (db)] Error from TOC entry 1063; 1259 47400432 SEQUENCE clube_seq_clube_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "clube_seq_clube_seq" already exists
    Command was: CREATE SEQUENCE public.clube_seq_clube_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.clube_seq_clube_seq"
pg_restore: creating TABLE "public.cobranca"
pg_restore: [archiver (db)] Error from TOC entry 1064; 1259 47400434 TABLE cobranca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca" already exists
    Command was: CREATE TABLE public.cobranca (
    seq_cobranca integer NOT NULL,
    descricao character varying(200),
    data_vencimento date,
    data_envio timestamp without time zone,
    data_retorno timestamp without time zone,
    seq_instituicao_financeira integer,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating TABLE "public.cobranca_retorno"
pg_restore: [archiver (db)] Error from TOC entry 1065; 1259 47400441 TABLE cobranca_retorno postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_retorno" already exists
    Command was: CREATE TABLE public.cobranca_retorno (
    seq_cobranca_retorno integer NOT NULL,
    titulo character varying(200),
    nosso_numero character varying(100),
    data_retorno timestamp without time zone DEFAULT now(),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    dt_retorno timestamp with time zone,
    cod_ocorrencia character varying(2),
    dt_ocorrecia date,
    dt_vencimento date,
    vlr_vencimento character varying(13),
    tp_documento character varying(2),
    vlr_desp_cob character varying(13),
    vlr_desp_out character varying(13),
    vlr_pago character varying(13),
    vlr_juros character varying(13),
    vlr_out character varying(13),
    vlr_desconto character varying(13),
    dt_credito date,
    nro_doc_empresa character varying(10),
    identificador character varying(50),
    dt_lido_sistema timestamp without time zone,
    seq_baixa integer
);



pg_restore: creating SEQUENCE "public.cobranca_retorno_seq_cobranca_retorno_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1066; 1259 47400446 SEQUENCE cobranca_retorno_seq_cobranca_retorno_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_retorno_seq_cobranca_retorno_seq_1" already exists
    Command was: CREATE SEQUENCE public.cobranca_retorno_seq_cobranca_retorno_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_retorno_seq_cobranca_retorno_seq_1"
pg_restore: creating SEQUENCE "public.cobranca_seq_cobranca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1067; 1259 47400448 SEQUENCE cobranca_seq_cobranca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_seq_cobranca_seq" already exists
    Command was: CREATE SEQUENCE public.cobranca_seq_cobranca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_seq_cobranca_seq"
pg_restore: creating TABLE "public.cobranca_titulo"
pg_restore: [archiver (db)] Error from TOC entry 1068; 1259 47400450 TABLE cobranca_titulo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo" already exists
    Command was: CREATE TABLE public.cobranca_titulo (
    seq_cobranca_titulo integer NOT NULL,
    seq_cobranca_retorno integer,
    nosso_numero character varying(100),
    titulo character varying(200),
    status character varying(10),
    valor_total numeric(20,5),
    valor_pago numeric(20,5),
    valor_desconto numeric(20,5),
    mensagem text,
    data_pagamento timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pessoa integer,
    seq_remessa integer,
    seq_movimento integer,
    dt_vencimento date
);



pg_restore: creating TABLE "public.cobranca_titulo_item"
pg_restore: [archiver (db)] Error from TOC entry 1069; 1259 47400457 TABLE cobranca_titulo_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo_item" already exists
    Command was: CREATE TABLE public.cobranca_titulo_item (
    seq_cobranca_titulo_item integer NOT NULL,
    seq_cobranca_titulo integer NOT NULL,
    valor numeric(20,5),
    seq_movimento_cobranca integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.cobranca_titulo_item_seq_cobranca_titulo_item_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1070; 1259 47400461 SEQUENCE cobranca_titulo_item_seq_cobranca_titulo_item_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo_item_seq_cobranca_titulo_item_seq_1" already exists
    Command was: CREATE SEQUENCE public.cobranca_titulo_item_seq_cobranca_titulo_item_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_titulo_item_seq_cobranca_titulo_item_seq_1"
pg_restore: creating SEQUENCE "public.cobranca_titulo_seq_cobranca_titulo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1071; 1259 47400463 SEQUENCE cobranca_titulo_seq_cobranca_titulo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo_seq_cobranca_titulo_seq" already exists
    Command was: CREATE SEQUENCE public.cobranca_titulo_seq_cobranca_titulo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_titulo_seq_cobranca_titulo_seq"
pg_restore: creating TABLE "public.competencia"
pg_restore: [archiver (db)] Error from TOC entry 1072; 1259 47400465 TABLE competencia postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competencia" already exists
    Command was: CREATE TABLE public.competencia (
    data_ini date,
    data_fim date,
    competencia character varying(10) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    periodicidade character varying
);



pg_restore: creating TABLE "public.competicao"
pg_restore: [archiver (db)] Error from TOC entry 1073; 1259 47400472 TABLE competicao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao" already exists
    Command was: CREATE TABLE public.competicao (
    seq_competicao integer NOT NULL,
    nome character varying(100) NOT NULL,
    observacao character varying,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating TABLE "public.competicao_edicao"
pg_restore: [archiver (db)] Error from TOC entry 1074; 1259 47400480 TABLE competicao_edicao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao_edicao" already exists
    Command was: CREATE TABLE public.competicao_edicao (
    seq_competicao_edicao integer NOT NULL,
    ano_base integer NOT NULL,
    dt_inicio date NOT NULL,
    observacao character varying,
    dt_fim date,
    seq_competicao integer NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.competicao_edicao_seq_competicao_edicao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1075; 1259 47400488 SEQUENCE competicao_edicao_seq_competicao_edicao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao_edicao_seq_competicao_edicao_seq" already exists
    Command was: CREATE SEQUENCE public.competicao_edicao_seq_competicao_edicao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.competicao_edicao_seq_competicao_edicao_seq"
pg_restore: creating SEQUENCE "public.competicao_seq_competicao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1076; 1259 47400490 SEQUENCE competicao_seq_competicao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao_seq_competicao_seq" already exists
    Command was: CREATE SEQUENCE public.competicao_seq_competicao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.competicao_seq_competicao_seq"
pg_restore: creating TABLE "public.conta"
pg_restore: [archiver (db)] Error from TOC entry 1077; 1259 47400492 TABLE conta postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "conta" already exists
    Command was: CREATE TABLE public.conta (
    seq_conta integer DEFAULT nextval(('seq_conta'::text)::regclass) NOT NULL,
    esq integer,
    nome character varying(100) NOT NULL,
    data_geracao timestamp without time zone DEFAULT now() NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    dir integer,
    nivel integer,
    conta_pai integer,
    caminho text,
    cod_contabil bigint,
    cod_centro_custo bigint,
    cod_usuario_alteracao integer
);



pg_restore: creating TABLE "public.dbf_cartoes_ecnh"
pg_restore: [archiver (db)] Error from TOC entry 1078; 1259 47400500 TABLE dbf_cartoes_ecnh postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dbf_cartoes_ecnh" already exists
    Command was: CREATE TABLE public.dbf_cartoes_ecnh (
    nrident character varying(255),
    barra character varying(255),
    tipoident character varying(255),
    matricula character varying(255),
    nome character varying(255),
    chave character varying(255),
    chavedes character varying(255),
    categoria character varying(255),
    status character varying(255),
    dtstatus character varying(255),
    tipolayout character varying(255)
);



pg_restore: creating TABLE "public.dbf_pessoas_ecnh"
pg_restore: [archiver (db)] Error from TOC entry 1079; 1259 47400506 TABLE dbf_pessoas_ecnh postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dbf_pessoas_ecnh" already exists
    Command was: CREATE TABLE public.dbf_pessoas_ecnh (
    tipo character varying(255),
    matricula character varying(255),
    nome character varying(255),
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso" already exists
    Command was: CREATE TABLE public.acesso (
    seq_acesso integer NOT NULL,
    codigo character varying(100) NOT NULL,
    status character varying(5) NOT NULL,
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    seq_catraca integer,
    tipo character varying(20)
);



pg_restore: creating TABLE "public.acesso_historico"
pg_restore: [archiver (db)] Error from TOC entry 1042; 1259 47400350 TABLE acesso_historico postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso_historico" already exists
    Command was: CREATE TABLE public.acesso_historico (
    seq_acesso_historico integer NOT NULL,
    codigo character varying(100) NOT NULL,
    status character varying(5) NOT NULL,
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    seq_evento integer,
    seq_produto integer,
    seq_catraca integer,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    tipo character varying(20),
    mensegem text
);



pg_restore: creating SEQUENCE "public.acesso_historico_seq_acesso_historico_seq"
pg_restore: [archiver (db)] Error from TOC entry 1043; 1259 47400357 SEQUENCE acesso_historico_seq_acesso_historico_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso_historico_seq_acesso_historico_seq" already exists
    Command was: CREATE SEQUENCE public.acesso_historico_seq_acesso_historico_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.acesso_historico_seq_acesso_historico_seq"
pg_restore: creating SEQUENCE "public.acesso_seq_acesso_seq"
pg_restore: [archiver (db)] Error from TOC entry 1044; 1259 47400359 SEQUENCE acesso_seq_acesso_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "acesso_seq_acesso_seq" already exists
    Command was: CREATE SEQUENCE public.acesso_seq_acesso_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.acesso_seq_acesso_seq"
pg_restore: creating TABLE "public.assento"
pg_restore: [archiver (db)] Error from TOC entry 1045; 1259 47400361 TABLE assento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "assento" already exists
    Command was: CREATE TABLE public.assento (
    seq_assento integer NOT NULL,
    seq_setor integer NOT NULL,
    fila_numero character varying(100),
    coordenada_x numeric(30,5),
    coordenada_y numeric(30,5),
    coordenada_z numeric(30,5),
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.assento_seq_assento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1046; 1259 47400366 SEQUENCE assento_seq_assento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "assento_seq_assento_seq" already exists
    Command was: CREATE SEQUENCE public.assento_seq_assento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.assento_seq_assento_seq"
pg_restore: creating TABLE "public.baixa"
pg_restore: [archiver (db)] Error from TOC entry 1047; 1259 47400368 TABLE baixa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "baixa" already exists
    Command was: CREATE TABLE public.baixa (
    seq_baixa integer NOT NULL,
    dt_importacao timestamp without time zone,
    qtd_registros bigint,
    arquivo character varying
);



pg_restore: creating SEQUENCE "public.baixa_seq_baixa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1048; 1259 47400374 SEQUENCE baixa_seq_baixa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "baixa_seq_baixa_seq" already exists
    Command was: CREATE SEQUENCE public.baixa_seq_baixa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.baixa_seq_baixa_seq"
pg_restore: creating TABLE "public.bilheteria"
pg_restore: [archiver (db)] Error from TOC entry 1049; 1259 47400376 TABLE bilheteria postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "bilheteria" already exists
    Command was: CREATE TABLE public.bilheteria (
    seq_bilheteria integer NOT NULL,
    nome character varying(100) NOT NULL,
    local character varying,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    seq_evento_local integer
);



pg_restore: creating SEQUENCE "public.bilheteria_seq_bilheteria_seq"
pg_restore: [archiver (db)] Error from TOC entry 1050; 1259 47400383 SEQUENCE bilheteria_seq_bilheteria_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "bilheteria_seq_bilheteria_seq" already exists
    Command was: CREATE SEQUENCE public.bilheteria_seq_bilheteria_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.bilheteria_seq_bilheteria_seq"
pg_restore: creating TABLE "public.boleto_macro"
pg_restore: [archiver (db)] Error from TOC entry 1051; 1259 47400385 TABLE boleto_macro postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "boleto_macro" already exists
    Command was: CREATE TABLE public.boleto_macro (
    seq_boleto_macro integer NOT NULL,
    matricula integer,
    competencia character varying(50),
    gerado boolean
);



pg_restore: creating SEQUENCE "public.boleto_macro_seq_boleto_macro_seq"
pg_restore: [archiver (db)] Error from TOC entry 1052; 1259 47400388 SEQUENCE boleto_macro_seq_boleto_macro_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "boleto_macro_seq_boleto_macro_seq" already exists
    Command was: CREATE SEQUENCE public.boleto_macro_seq_boleto_macro_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.boleto_macro_seq_boleto_macro_seq"
pg_restore: creating TABLE "public.cadeira"
pg_restore: [archiver (db)] Error from TOC entry 1053; 1259 47400390 TABLE cadeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cadeira" already exists
    Command was: CREATE TABLE public.cadeira (
    seq_cadeira integer NOT NULL,
    cadeira character varying(50),
    x integer,
    y integer,
    z integer,
    status character varying(50),
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.cadeira_seq_cadeira_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1054; 1259 47400397 SEQUENCE cadeira_seq_cadeira_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cadeira_seq_cadeira_seq_1" already exists
    Command was: CREATE SEQUENCE public.cadeira_seq_cadeira_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cadeira_seq_cadeira_seq_1"
pg_restore: creating TABLE "public.camarote"
pg_restore: [archiver (db)] Error from TOC entry 1055; 1259 47400399 TABLE camarote postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "camarote" already exists
    Command was: CREATE TABLE public.camarote (
    seq_camarote integer NOT NULL,
    nome character varying(200),
    quantidade_cadeiras integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.camarote_seq_camarote_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1056; 1259 47400403 SEQUENCE camarote_seq_camarote_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "camarote_seq_camarote_seq_1" already exists
    Command was: CREATE SEQUENCE public.camarote_seq_camarote_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.camarote_seq_camarote_seq_1"
pg_restore: creating SEQUENCE "public.seq_cartao2"
pg_restore: [archiver (db)] Error from TOC entry 1057; 1259 47400405 SEQUENCE seq_cartao2 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_cartao2" already exists
    Command was: CREATE SEQUENCE public.seq_cartao2
    START WITH 2300
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.cartao"
pg_restore: [archiver (db)] Error from TOC entry 1058; 1259 47400407 TABLE cartao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cartao" already exists
    Command was: CREATE TABLE public.cartao (
    seq_cartao integer DEFAULT nextval('public.seq_cartao2'::regclass) NOT NULL,
    matricula integer NOT NULL,
    chip character varying(100),
    data_cancelamento timestamp without time zone,
    data_sincronia timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    cod_barra character varying(50)
);



pg_restore: creating TABLE "public.catraca"
pg_restore: [archiver (db)] Error from TOC entry 1059; 1259 47400412 TABLE catraca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "catraca" already exists
    Command was: CREATE TABLE public.catraca (
    seq_catraca integer NOT NULL,
    seq_portao integer,
    catraca character varying(100) NOT NULL,
    ip character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    nro_catraca integer
);



pg_restore: creating SEQUENCE "public.catraca_seq_catraca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1060; 1259 47400416 SEQUENCE catraca_seq_catraca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "catraca_seq_catraca_seq" already exists
    Command was: CREATE SEQUENCE public.catraca_seq_catraca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.catraca_seq_catraca_seq"
pg_restore: creating TABLE "public.ci_sessions"
pg_restore: [archiver (db)] Error from TOC entry 1061; 1259 47400418 TABLE ci_sessions postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ci_sessions" already exists
    Command was: CREATE TABLE public.ci_sessions (
    session_id character varying(40) DEFAULT '0'::character varying NOT NULL,
    ip_address character varying(45) DEFAULT '0'::character varying NOT NULL,
    user_agent character varying(120) NOT NULL,
    last_activity integer DEFAULT 0 NOT NULL,
    user_data text NOT NULL
);



pg_restore: creating TABLE "public.clube"
pg_restore: [archiver (db)] Error from TOC entry 1062; 1259 47400427 TABLE clube postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "clube" already exists
    Command was: CREATE TABLE public.clube (
    seq_clube integer NOT NULL,
    nome character varying(100) NOT NULL,
    logo character varying(255),
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.clube_seq_clube_seq"
pg_restore: [archiver (db)] Error from TOC entry 1063; 1259 47400432 SEQUENCE clube_seq_clube_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "clube_seq_clube_seq" already exists
    Command was: CREATE SEQUENCE public.clube_seq_clube_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.clube_seq_clube_seq"
pg_restore: creating TABLE "public.cobranca"
pg_restore: [archiver (db)] Error from TOC entry 1064; 1259 47400434 TABLE cobranca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca" already exists
    Command was: CREATE TABLE public.cobranca (
    seq_cobranca integer NOT NULL,
    descricao character varying(200),
    data_vencimento date,
    data_envio timestamp without time zone,
    data_retorno timestamp without time zone,
    seq_instituicao_financeira integer,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating TABLE "public.cobranca_retorno"
pg_restore: [archiver (db)] Error from TOC entry 1065; 1259 47400441 TABLE cobranca_retorno postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_retorno" already exists
    Command was: CREATE TABLE public.cobranca_retorno (
    seq_cobranca_retorno integer NOT NULL,
    titulo character varying(200),
    nosso_numero character varying(100),
    data_retorno timestamp without time zone DEFAULT now(),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    dt_retorno timestamp with time zone,
    cod_ocorrencia character varying(2),
    dt_ocorrecia date,
    dt_vencimento date,
    vlr_vencimento character varying(13),
    tp_documento character varying(2),
    vlr_desp_cob character varying(13),
    vlr_desp_out character varying(13),
    vlr_pago character varying(13),
    vlr_juros character varying(13),
    vlr_out character varying(13),
    vlr_desconto character varying(13),
    dt_credito date,
    nro_doc_empresa character varying(10),
    identificador character varying(50),
    dt_lido_sistema timestamp without time zone,
    seq_baixa integer
);



pg_restore: creating SEQUENCE "public.cobranca_retorno_seq_cobranca_retorno_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1066; 1259 47400446 SEQUENCE cobranca_retorno_seq_cobranca_retorno_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_retorno_seq_cobranca_retorno_seq_1" already exists
    Command was: CREATE SEQUENCE public.cobranca_retorno_seq_cobranca_retorno_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_retorno_seq_cobranca_retorno_seq_1"
pg_restore: creating SEQUENCE "public.cobranca_seq_cobranca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1067; 1259 47400448 SEQUENCE cobranca_seq_cobranca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_seq_cobranca_seq" already exists
    Command was: CREATE SEQUENCE public.cobranca_seq_cobranca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_seq_cobranca_seq"
pg_restore: creating TABLE "public.cobranca_titulo"
pg_restore: [archiver (db)] Error from TOC entry 1068; 1259 47400450 TABLE cobranca_titulo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo" already exists
    Command was: CREATE TABLE public.cobranca_titulo (
    seq_cobranca_titulo integer NOT NULL,
    seq_cobranca_retorno integer,
    nosso_numero character varying(100),
    titulo character varying(200),
    status character varying(10),
    valor_total numeric(20,5),
    valor_pago numeric(20,5),
    valor_desconto numeric(20,5),
    mensagem text,
    data_pagamento timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pessoa integer,
    seq_remessa integer,
    seq_movimento integer,
    dt_vencimento date
);



pg_restore: creating TABLE "public.cobranca_titulo_item"
pg_restore: [archiver (db)] Error from TOC entry 1069; 1259 47400457 TABLE cobranca_titulo_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo_item" already exists
    Command was: CREATE TABLE public.cobranca_titulo_item (
    seq_cobranca_titulo_item integer NOT NULL,
    seq_cobranca_titulo integer NOT NULL,
    valor numeric(20,5),
    seq_movimento_cobranca integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.cobranca_titulo_item_seq_cobranca_titulo_item_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1070; 1259 47400461 SEQUENCE cobranca_titulo_item_seq_cobranca_titulo_item_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo_item_seq_cobranca_titulo_item_seq_1" already exists
    Command was: CREATE SEQUENCE public.cobranca_titulo_item_seq_cobranca_titulo_item_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_titulo_item_seq_cobranca_titulo_item_seq_1"
pg_restore: creating SEQUENCE "public.cobranca_titulo_seq_cobranca_titulo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1071; 1259 47400463 SEQUENCE cobranca_titulo_seq_cobranca_titulo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "cobranca_titulo_seq_cobranca_titulo_seq" already exists
    Command was: CREATE SEQUENCE public.cobranca_titulo_seq_cobranca_titulo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.cobranca_titulo_seq_cobranca_titulo_seq"
pg_restore: creating TABLE "public.competencia"
pg_restore: [archiver (db)] Error from TOC entry 1072; 1259 47400465 TABLE competencia postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competencia" already exists
    Command was: CREATE TABLE public.competencia (
    data_ini date,
    data_fim date,
    competencia character varying(10) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    periodicidade character varying
);



pg_restore: creating TABLE "public.competicao"
pg_restore: [archiver (db)] Error from TOC entry 1073; 1259 47400472 TABLE competicao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao" already exists
    Command was: CREATE TABLE public.competicao (
    seq_competicao integer NOT NULL,
    nome character varying(100) NOT NULL,
    observacao character varying,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating TABLE "public.competicao_edicao"
pg_restore: [archiver (db)] Error from TOC entry 1074; 1259 47400480 TABLE competicao_edicao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao_edicao" already exists
    Command was: CREATE TABLE public.competicao_edicao (
    seq_competicao_edicao integer NOT NULL,
    ano_base integer NOT NULL,
    dt_inicio date NOT NULL,
    observacao character varying,
    dt_fim date,
    seq_competicao integer NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.competicao_edicao_seq_competicao_edicao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1075; 1259 47400488 SEQUENCE competicao_edicao_seq_competicao_edicao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao_edicao_seq_competicao_edicao_seq" already exists
    Command was: CREATE SEQUENCE public.competicao_edicao_seq_competicao_edicao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.competicao_edicao_seq_competicao_edicao_seq"
pg_restore: creating SEQUENCE "public.competicao_seq_competicao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1076; 1259 47400490 SEQUENCE competicao_seq_competicao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "competicao_seq_competicao_seq" already exists
    Command was: CREATE SEQUENCE public.competicao_seq_competicao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.competicao_seq_competicao_seq"
pg_restore: creating TABLE "public.conta"
pg_restore: [archiver (db)] Error from TOC entry 1077; 1259 47400492 TABLE conta postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "conta" already exists
    Command was: CREATE TABLE public.conta (
    seq_conta integer DEFAULT nextval(('seq_conta'::text)::regclass) NOT NULL,
    esq integer,
    nome character varying(100) NOT NULL,
    data_geracao timestamp without time zone DEFAULT now() NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    dir integer,
    nivel integer,
    conta_pai integer,
    caminho text,
    cod_contabil bigint,
    cod_centro_custo bigint,
    cod_usuario_alteracao integer
);



pg_restore: creating TABLE "public.dbf_cartoes_ecnh"
pg_restore: [archiver (db)] Error from TOC entry 1078; 1259 47400500 TABLE dbf_cartoes_ecnh postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dbf_cartoes_ecnh" already exists
    Command was: CREATE TABLE public.dbf_cartoes_ecnh (
    nrident character varying(255),
    barra character varying(255),
    tipoident character varying(255),
    matricula character varying(255),
    nome character varying(255),
    chave character varying(255),
    chavedes character varying(255),
    categoria character varying(255),
    status character varying(255),
    dtstatus character varying(255),
    tipolayout character varying(255)
);



pg_restore: creating TABLE "public.dbf_pessoas_ecnh"
pg_restore: [archiver (db)] Error from TOC entry 1079; 1259 47400506 TABLE dbf_pessoas_ecnh postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dbf_pessoas_ecnh" already exists
    Command was: CREATE TABLE public.dbf_pessoas_ecnh (
    tipo character varying(255),
    matricula character varying(255),
    nome character varying(255),
    sobrenome character varying(255),
    sexo character varying(255),
    ecivil character varying(255),
    dtnascim character varying(255),
    dtcadastr character varying(255),
    dtadmiss character varying(255),
    tipoadmiss character varying(255),
    nrtitulo character varying(255),
    dttitulo character varying(255),
    matpropon character varying(255),
    nomepropon character varying(255),
    pai character varying(255),
    mae character varying(255),
    cpf character varying(255),
    identidade character varying(255),
    categoria character varying(255),
    celular character varying(255),
    endresi character varying(255),
    nrresi character varying(255),
    comresi character varying(255),
    bairesi character varying(255),
    cepresi character varying(255),
    telresi character varying(255),
    emaresi character varying(255),
    empresa character varying(255),
    endcoml character varying(255),
    nrcoml character varying(255),
    comcoml character varying(255),
    baicoml character varying(255),
    cepcoml character varying(255),
    telcoml character varying(255),
    emacom character varying(255)
);



pg_restore: creating TABLE "public.dne"
pg_restore: [archiver (db)] Error from TOC entry 1080; 1259 47400512 TABLE dne postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dne" already exists
    Command was: CREATE TABLE public.dne (
    cep character varying(8),
    localidade character varying(100),
    uf character varying(2),
    bairro_inicial character varying(100),
    bairro_final character varying(100),
    logradouro character varying(100),
    posicao_exercito integer,
    seq_dne integer NOT NULL
);



pg_restore: creating SEQUENCE "public.dne_seq_dne_seq"
pg_restore: [archiver (db)] Error from TOC entry 1081; 1259 47400515 SEQUENCE dne_seq_dne_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dne_seq_dne_seq" already exists
    Command was: CREATE SEQUENCE public.dne_seq_dne_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.dne_seq_dne_seq"
pg_restore: creating TABLE "public.escolaridade"
pg_restore: [archiver (db)] Error from TOC entry 1082; 1259 47400517 TABLE escolaridade postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "escolaridade" already exists
    Command was: CREATE TABLE public.escolaridade (
    seq_escolaridade integer NOT NULL,
    descricao character varying(200)
);



pg_restore: creating SEQUENCE "public.escolaridade_seq_escolaridade_seq"
pg_restore: [archiver (db)] Error from TOC entry 1083; 1259 47400520 SEQUENCE escolaridade_seq_escolaridade_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "escolaridade_seq_escolaridade_seq" already exists
    Command was: CREATE SEQUENCE public.escolaridade_seq_escolaridade_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.escolaridade_seq_escolaridade_seq"
pg_restore: creating TABLE "public.estado"
pg_restore: [archiver (db)] Error from TOC entry 1084; 1259 47400522 TABLE estado postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "estado" already exists
    Command was: CREATE TABLE public.estado (
    seq_estado integer NOT NULL,
    nome character varying(50),
    sigla character varying(2)
);



pg_restore: creating SEQUENCE "public.estado_seq_estado_seq"
pg_restore: [archiver (db)] Error from TOC entry 1085; 1259 47400525 SEQUENCE estado_seq_estado_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "estado_seq_estado_seq" already exists
    Command was: CREATE SEQUENCE public.estado_seq_estado_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.estado_seq_estado_seq"
pg_restore: creating TABLE "public.evento"
pg_restore: [archiver (db)] Error from TOC entry 1086; 1259 47400527 TABLE evento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento" already exists
    Command was: CREATE TABLE public.evento (
    seq_evento integer NOT NULL,
    seq_competicao_edicao integer NOT NULL,
    seguradora character varying(100) NOT NULL,
    seq_clube_adversario integer,
    dt_evento timestamp without time zone NOT NULL,
    numero_seguro character varying(100),
    descricao character varying(200),
    seq_evento_local integer DEFAULT 1 NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    objetivo integer,
    meta_publico integer,
    clima integer,
    temperatura numeric(20,2),
    gol_tempo_normal_pro integer,
    gol_tempo_normal_contra integer,
    gol_tempo_extra_pro integer,
    gol_tempo_extra_contra integer,
    penalti_pro integer,
    penalti_contra integer,
    even_ref integer
);



pg_restore: creating TABLE "public.evento_local"
pg_restore: [archiver (db)] Error from TOC entry 1087; 1259 47400532 TABLE evento_local postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_local" already exists
    Command was: CREATE TABLE public.evento_local (
    seq_evento_local integer NOT NULL,
    cep integer NOT NULL,
    nome character varying(100) NOT NULL,
    observacao character varying,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    link_google_maps text
);



pg_restore: creating SEQUENCE "public.evento_local_seq_evento_local_seq"
pg_restore: [archiver (db)] Error from TOC entry 1088; 1259 47400539 SEQUENCE evento_local_seq_evento_local_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_local_seq_evento_local_seq" already exists
    Command was: CREATE SEQUENCE public.evento_local_seq_evento_local_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_local_seq_evento_local_seq"
pg_restore: creating TABLE "public.evento_objetivo"
pg_restore: [archiver (db)] Error from TOC entry 1089; 1259 47400541 TABLE evento_objetivo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_objetivo" already exists
    Command was: CREATE TABLE public.evento_objetivo (
    seq_evento_objetivo integer NOT NULL,
    objetivo text,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.evento_objetivo_seq_evento_objetivo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1090; 1259 47400548 SEQUENCE evento_objetivo_seq_evento_objetivo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_objetivo_seq_evento_objetivo_seq" already exists
    Command was: CREATE SEQUENCE public.evento_objetivo_seq_evento_objetivo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_objetivo_seq_evento_objetivo_seq"
pg_restore: creating TABLE "public.evento_produto"
pg_restore: [archiver (db)] Error from TOC entry 1091; 1259 47400550 TABLE evento_produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_produto" already exists
    Command was: CREATE TABLE public.evento_produto (
    seq_evento_produto integer NOT NULL,
    seq_evento integer NOT NULL,
    seq_produto integer NOT NULL,
    qtde integer NOT NULL,
    valor numeric(30,5) NOT NULL,
    observacao character varying,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.evento_produto_seq_evento_produto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1092; 1259 47400557 SEQUENCE evento_produto_seq_evento_produto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_produto_seq_evento_produto_seq" already exists
    Command was: CREATE SEQUENCE public.evento_produto_seq_evento_produto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_produto_seq_evento_produto_seq"
pg_restore: creating SEQUENCE "public.evento_seq_evento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1093; 1259 47400559 SEQUENCE evento_seq_evento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_seq_evento_seq" already exists
    Command was: CREATE SEQUENCE public.evento_seq_evento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_seq_evento_seq"
pg_restore: creating TABLE "public.faixa_salarial"
pg_restore: [archiver (db)] Error from TOC entry 1094; 1259 47400561 TABLE faixa_salarial postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "faixa_salarial" already exists
    Command was: CREATE TABLE public.faixa_salarial (
    seq_faixa_salarial integer NOT NULL,
    descricao character varying
);



pg_restore: creating SEQUENCE "public.faixa_salarial_seq_faixa_salarial_seq"
pg_restore: [archiver (db)] Error from TOC entry 1095; 1259 47400567 SEQUENCE faixa_salarial_seq_faixa_salarial_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "faixa_salarial_seq_faixa_salarial_seq" already exists
    Command was: CREATE SEQUENCE public.faixa_salarial_seq_faixa_salarial_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.faixa_salarial_seq_faixa_salarial_seq"
pg_restore: creating TABLE "public.forma_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1096; 1259 47400569 TABLE forma_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "forma_pagamento" already exists
    Command was: CREATE TABLE public.forma_pagamento (
    seq_forma_pagamento integer NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.forma_pagamento_seq_forma_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1097; 1259 47400574 SEQUENCE forma_pagamento_seq_forma_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "forma_pagamento_seq_forma_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.forma_pagamento_seq_forma_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.forma_pagamento_seq_forma_pagamento_seq"
pg_restore: creating TABLE "public.ingresso"
pg_restore: [archiver (db)] Error from TOC entry 1098; 1259 47400576 TABLE ingresso postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ingresso" already exists
    Command was: CREATE TABLE public.ingresso (
    seq_ingresso integer NOT NULL,
    seq_sessao_evento_produto integer,
    seq_pessoa integer,
    seq_assento integer,
    nro_codigo_barras character varying(200) NOT NULL,
    nro_ingresso character varying(100),
    nro_2d character varying,
    nro_protocolo character varying(100),
    seq_cartao integer,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    dt_cancelamento timestamp without time zone,
    seq_movimento_item integer,
    dt_entrega timestamp without time zone,
    tipo character varying(50),
    seq_ingresso_vinculo integer,
    valor_pago numeric(30,5),
    valor_devido numeric(30,5),
    seq_evento_produto integer,
    meio_ingresso boolean DEFAULT false NOT NULL
);



pg_restore: creating TABLE "public.ingresso_numero"
pg_restore: [archiver (db)] Error from TOC entry 1099; 1259 47400584 TABLE ingresso_numero postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ingresso_numero" already exists
    Command was: CREATE TABLE public.ingresso_numero (
    ingresso_numero bigint NOT NULL,
    usado boolean DEFAULT false,
    even_ref integer,
    seq bigint
);



pg_restore: creating SEQUENCE "public.ingresso_seq_ingresso_seq"
pg_restore: [archiver (db)] Error from TOC entry 1100; 1259 47400588 SEQUENCE ingresso_seq_ingresso_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ingresso_seq_ingresso_seq" already exists
    Command was: CREATE SEQUENCE public.ingresso_seq_ingresso_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.ingresso_seq_ingresso_seq"
pg_restore: creating TABLE "public.instituicao_financeira"
pg_restore: [archiver (db)] Error from TOC entry 1101; 1259 47400590 TABLE instituicao_financeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "instituicao_financeira" already exists
    Command was: CREATE TABLE public.instituicao_financeira (
    seq_instituicao_financeira integer NOT NULL,
    nome character varying(200),
    tipo character varying(20),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    codigo character varying(100)
);



pg_restore: creating SEQUENCE "public.seq_seq_liberacao"
pg_restore: [archiver (db)] Error from TOC entry 1102; 1259 47400594 SEQUENCE seq_seq_liberacao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_seq_liberacao" already exists
    Command was: CREATE SEQUENCE public.seq_seq_liberacao
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.liberacao"
pg_restore: [archiver (db)] Error from TOC entry 1103; 1259 47400596 TABLE liberacao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "liberacao" already exists
    Command was: CREATE TABLE public.liberacao (
    seq_liberacao integer DEFAULT nextval('public.seq_seq_liberacao'::regclass) NOT NULL,
    codigo character varying(100) NOT NULL,
    seq_produto integer NOT NULL,
    status character varying(5),
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    tipo_acesso character varying(20),
    mensagem character varying(50)
);



pg_restore: creating SEQUENCE "public.seq_liberacao_historico"
pg_restore: [archiver (db)] Error from TOC entry 1104; 1259 47400601 SEQUENCE seq_liberacao_historico postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_liberacao_historico" already exists
    Command was: CREATE SEQUENCE public.seq_liberacao_historico
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.liberacao_historico"
pg_restore: [archiver (db)] Error from TOC entry 1105; 1259 47400603 TABLE liberacao_historico postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "liberacao_historico" already exists
    Command was: CREATE TABLE public.liberacao_historico (
    seq_liberacao_historico integer DEFAULT nextval('public.seq_liberacao_historico'::regclass) NOT NULL,
    seq_liberacao integer,
    codigo character varying(100) NOT NULL,
    seq_produto integer,
    status character varying(5),
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    tipo_acesso character varying(20),
    mensagem character varying(16),
    seq_evento integer
);



pg_restore: creating TABLE "public.matricula"
pg_restore: [archiver (db)] Error from TOC entry 1106; 1259 47400608 TABLE matricula postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "matricula" already exists
    Command was: CREATE TABLE public.matricula (
    matricula integer NOT NULL,
    seq_pessoa integer NOT NULL,
    seq_produto integer NOT NULL,
    seq_cadeira integer,
    seq_camarote integer,
    data_criacao timestamp without time zone,
    data_aquisicao timestamp without time zone,
    data_cancelamento timestamp without time zone,
    dia_cobranca date,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pagador integer,
    em_dia boolean DEFAULT false,
    seq_pessoa_dados_pagamento integer,
    seq_forma_pagamento integer DEFAULT 1 NOT NULL,
    seq_instituicao_financeira integer,
    cob_conta character varying(100),
    cob_agencia character varying(100),
    cob_numero_cartao character varying(100),
    cob_data_vencimento_cartao date,
    cob_codigo_seguranca_cartao character varying(20),
    cob_cep character varying(30),
    cob_endereco character varying(200),
    cob_bairro character varying(100),
    cob_cidade character varying(100),
    cob_uf character varying(20),
    cob_pais integer,
    cob_complemento character varying(200),
    cob_numero integer,
    ativa boolean,
    numero_cartao character varying(50),
    seq_vinculado integer,
    seq_plano_pgto integer,
    matricula_acbf character varying(50),
    seq_produto_escolinha_turma integer
);



pg_restore: creating TABLE "public.movimento_cobranca"
pg_restore: [archiver (db)] Error from TOC entry 1107; 1259 47400614 TABLE movimento_cobranca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_cobranca" already exists
    Command was: CREATE TABLE public.movimento_cobranca (
    seq_movimento_cobranca integer NOT NULL,
    matricula integer,
    seq_produto_taxa integer,
    valor_devido numeric(20,5),
    valor_pago numeric(20,5),
    data_vencimento date,
    data_pagamento timestamp without time zone,
    data_cancelamento timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pessoa integer,
    competencia character varying(10)
);



pg_restore: creating SEQUENCE "public.matricula_cobranca_seq_matricula_cobranca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1108; 1259 47400618 SEQUENCE matricula_cobranca_seq_matricula_cobranca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "matricula_cobranca_seq_matricula_cobranca_seq" already exists
    Command was: CREATE SEQUENCE public.matricula_cobranca_seq_matricula_cobranca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.matricula_cobranca_seq_matricula_cobranca_seq"
pg_restore: creating SEQUENCE "public.matricula_matricula_seq"
pg_restore: [archiver (db)] Error from TOC entry 1109; 1259 47400620 SEQUENCE matricula_matricula_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "matricula_matricula_seq" already exists
    Command was: CREATE SEQUENCE public.matricula_matricula_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.matricula_matricula_seq"
pg_restore: creating TABLE "public.meio_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1110; 1259 47400622 TABLE meio_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "meio_pagamento" already exists
    Command was: CREATE TABLE public.meio_pagamento (
    seq_meio_pagamento integer NOT NULL,
    nome character varying(100) NOT NULL,
    cod_integracao character varying(100) NOT NULL,
    seq_forma_pagamento integer NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.meio_pagamento_seq_meio_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1111; 1259 47400627 SEQUENCE meio_pagamento_seq_meio_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "meio_pagamento_seq_meio_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.meio_pagamento_seq_meio_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.meio_pagamento_seq_meio_pagamento_seq"
pg_restore: creating TABLE "public.menu"
pg_restore: [archiver (db)] Error from TOC entry 1112; 1259 47400629 TABLE menu postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "menu" already exists
    Command was: CREATE TABLE public.menu (
    seq_menu integer NOT NULL,
    texto character varying(50),
    objeto integer,
    pai integer,
    icone character varying(50),
    ativo boolean DEFAULT true
);



pg_restore: creating SEQUENCE "public.menu_seq_menu_seq"
pg_restore: [archiver (db)] Error from TOC entry 1113; 1259 47400633 SEQUENCE menu_seq_menu_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "menu_seq_menu_seq" already exists
    Command was: CREATE SEQUENCE public.menu_seq_menu_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.menu_seq_menu_seq"
pg_restore: creating TABLE "public.movimento"
pg_restore: [archiver (db)] Error from TOC entry 1114; 1259 47400635 TABLE movimento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento" already exists
    Command was: CREATE TABLE public.movimento (
    seq_movimento integer NOT NULL,
    data_criacao timestamp without time zone DEFAULT now(),
    data_pagamento timestamp without time zone,
    valor_total numeric(20,5),
    caixa integer,
    data_estorno timestamp without time zone,
    usuario_alteracao character varying(100),
    sobrenome character varying(255),
    sexo character varying(255),
    ecivil character varying(255),
    dtnascim character varying(255),
    dtcadastr character varying(255),
    dtadmiss character varying(255),
    tipoadmiss character varying(255),
    nrtitulo character varying(255),
    dttitulo character varying(255),
    matpropon character varying(255),
    nomepropon character varying(255),
    pai character varying(255),
    mae character varying(255),
    cpf character varying(255),
    identidade character varying(255),
    categoria character varying(255),
    celular character varying(255),
    endresi character varying(255),
    nrresi character varying(255),
    comresi character varying(255),
    bairesi character varying(255),
    cepresi character varying(255),
    telresi character varying(255),
    emaresi character varying(255),
    empresa character varying(255),
    endcoml character varying(255),
    nrcoml character varying(255),
    comcoml character varying(255),
    baicoml character varying(255),
    cepcoml character varying(255),
    telcoml character varying(255),
    emacom character varying(255)
);



pg_restore: creating TABLE "public.dne"
pg_restore: [archiver (db)] Error from TOC entry 1080; 1259 47400512 TABLE dne postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dne" already exists
    Command was: CREATE TABLE public.dne (
    cep character varying(8),
    localidade character varying(100),
    uf character varying(2),
    bairro_inicial character varying(100),
    bairro_final character varying(100),
    logradouro character varying(100),
    posicao_exercito integer,
    seq_dne integer NOT NULL
);



pg_restore: creating SEQUENCE "public.dne_seq_dne_seq"
pg_restore: [archiver (db)] Error from TOC entry 1081; 1259 47400515 SEQUENCE dne_seq_dne_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dne_seq_dne_seq" already exists
    Command was: CREATE SEQUENCE public.dne_seq_dne_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.dne_seq_dne_seq"
pg_restore: creating TABLE "public.escolaridade"
pg_restore: [archiver (db)] Error from TOC entry 1082; 1259 47400517 TABLE escolaridade postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "escolaridade" already exists
    Command was: CREATE TABLE public.escolaridade (
    seq_escolaridade integer NOT NULL,
    descricao character varying(200)
);



pg_restore: creating SEQUENCE "public.escolaridade_seq_escolaridade_seq"
pg_restore: [archiver (db)] Error from TOC entry 1083; 1259 47400520 SEQUENCE escolaridade_seq_escolaridade_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "escolaridade_seq_escolaridade_seq" already exists
    Command was: CREATE SEQUENCE public.escolaridade_seq_escolaridade_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.escolaridade_seq_escolaridade_seq"
pg_restore: creating TABLE "public.estado"
pg_restore: [archiver (db)] Error from TOC entry 1084; 1259 47400522 TABLE estado postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "estado" already exists
    Command was: CREATE TABLE public.estado (
    seq_estado integer NOT NULL,
    nome character varying(50),
    sigla character varying(2)
);



pg_restore: creating SEQUENCE "public.estado_seq_estado_seq"
pg_restore: [archiver (db)] Error from TOC entry 1085; 1259 47400525 SEQUENCE estado_seq_estado_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "estado_seq_estado_seq" already exists
    Command was: CREATE SEQUENCE public.estado_seq_estado_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.estado_seq_estado_seq"
pg_restore: creating TABLE "public.evento"
pg_restore: [archiver (db)] Error from TOC entry 1086; 1259 47400527 TABLE evento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento" already exists
    Command was: CREATE TABLE public.evento (
    seq_evento integer NOT NULL,
    seq_competicao_edicao integer NOT NULL,
    seguradora character varying(100) NOT NULL,
    seq_clube_adversario integer,
    dt_evento timestamp without time zone NOT NULL,
    numero_seguro character varying(100),
    descricao character varying(200),
    seq_evento_local integer DEFAULT 1 NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    objetivo integer,
    meta_publico integer,
    clima integer,
    temperatura numeric(20,2),
    gol_tempo_normal_pro integer,
    gol_tempo_normal_contra integer,
    gol_tempo_extra_pro integer,
    gol_tempo_extra_contra integer,
    penalti_pro integer,
    penalti_contra integer,
    even_ref integer
);



pg_restore: creating TABLE "public.evento_local"
pg_restore: [archiver (db)] Error from TOC entry 1087; 1259 47400532 TABLE evento_local postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_local" already exists
    Command was: CREATE TABLE public.evento_local (
    seq_evento_local integer NOT NULL,
    cep integer NOT NULL,
    nome character varying(100) NOT NULL,
    observacao character varying,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    link_google_maps text
);



pg_restore: creating SEQUENCE "public.evento_local_seq_evento_local_seq"
pg_restore: [archiver (db)] Error from TOC entry 1088; 1259 47400539 SEQUENCE evento_local_seq_evento_local_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_local_seq_evento_local_seq" already exists
    Command was: CREATE SEQUENCE public.evento_local_seq_evento_local_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_local_seq_evento_local_seq"
pg_restore: creating TABLE "public.evento_objetivo"
pg_restore: [archiver (db)] Error from TOC entry 1089; 1259 47400541 TABLE evento_objetivo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_objetivo" already exists
    Command was: CREATE TABLE public.evento_objetivo (
    seq_evento_objetivo integer NOT NULL,
    objetivo text,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.evento_objetivo_seq_evento_objetivo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1090; 1259 47400548 SEQUENCE evento_objetivo_seq_evento_objetivo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_objetivo_seq_evento_objetivo_seq" already exists
    Command was: CREATE SEQUENCE public.evento_objetivo_seq_evento_objetivo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_objetivo_seq_evento_objetivo_seq"
pg_restore: creating TABLE "public.evento_produto"
pg_restore: [archiver (db)] Error from TOC entry 1091; 1259 47400550 TABLE evento_produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_produto" already exists
    Command was: CREATE TABLE public.evento_produto (
    seq_evento_produto integer NOT NULL,
    seq_evento integer NOT NULL,
    seq_produto integer NOT NULL,
    qtde integer NOT NULL,
    valor numeric(30,5) NOT NULL,
    observacao character varying,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.evento_produto_seq_evento_produto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1092; 1259 47400557 SEQUENCE evento_produto_seq_evento_produto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_produto_seq_evento_produto_seq" already exists
    Command was: CREATE SEQUENCE public.evento_produto_seq_evento_produto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_produto_seq_evento_produto_seq"
pg_restore: creating SEQUENCE "public.evento_seq_evento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1093; 1259 47400559 SEQUENCE evento_seq_evento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "evento_seq_evento_seq" already exists
    Command was: CREATE SEQUENCE public.evento_seq_evento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.evento_seq_evento_seq"
pg_restore: creating TABLE "public.faixa_salarial"
pg_restore: [archiver (db)] Error from TOC entry 1094; 1259 47400561 TABLE faixa_salarial postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "faixa_salarial" already exists
    Command was: CREATE TABLE public.faixa_salarial (
    seq_faixa_salarial integer NOT NULL,
    descricao character varying
);



pg_restore: creating SEQUENCE "public.faixa_salarial_seq_faixa_salarial_seq"
pg_restore: [archiver (db)] Error from TOC entry 1095; 1259 47400567 SEQUENCE faixa_salarial_seq_faixa_salarial_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "faixa_salarial_seq_faixa_salarial_seq" already exists
    Command was: CREATE SEQUENCE public.faixa_salarial_seq_faixa_salarial_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.faixa_salarial_seq_faixa_salarial_seq"
pg_restore: creating TABLE "public.forma_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1096; 1259 47400569 TABLE forma_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "forma_pagamento" already exists
    Command was: CREATE TABLE public.forma_pagamento (
    seq_forma_pagamento integer NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.forma_pagamento_seq_forma_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1097; 1259 47400574 SEQUENCE forma_pagamento_seq_forma_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "forma_pagamento_seq_forma_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.forma_pagamento_seq_forma_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.forma_pagamento_seq_forma_pagamento_seq"
pg_restore: creating TABLE "public.ingresso"
pg_restore: [archiver (db)] Error from TOC entry 1098; 1259 47400576 TABLE ingresso postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ingresso" already exists
    Command was: CREATE TABLE public.ingresso (
    seq_ingresso integer NOT NULL,
    seq_sessao_evento_produto integer,
    seq_pessoa integer,
    seq_assento integer,
    nro_codigo_barras character varying(200) NOT NULL,
    nro_ingresso character varying(100),
    nro_2d character varying,
    nro_protocolo character varying(100),
    seq_cartao integer,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    dt_cancelamento timestamp without time zone,
    seq_movimento_item integer,
    dt_entrega timestamp without time zone,
    tipo character varying(50),
    seq_ingresso_vinculo integer,
    valor_pago numeric(30,5),
    valor_devido numeric(30,5),
    seq_evento_produto integer,
    meio_ingresso boolean DEFAULT false NOT NULL
);



pg_restore: creating TABLE "public.ingresso_numero"
pg_restore: [archiver (db)] Error from TOC entry 1099; 1259 47400584 TABLE ingresso_numero postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ingresso_numero" already exists
    Command was: CREATE TABLE public.ingresso_numero (
    ingresso_numero bigint NOT NULL,
    usado boolean DEFAULT false,
    even_ref integer,
    seq bigint
);



pg_restore: creating SEQUENCE "public.ingresso_seq_ingresso_seq"
pg_restore: [archiver (db)] Error from TOC entry 1100; 1259 47400588 SEQUENCE ingresso_seq_ingresso_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "ingresso_seq_ingresso_seq" already exists
    Command was: CREATE SEQUENCE public.ingresso_seq_ingresso_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.ingresso_seq_ingresso_seq"
pg_restore: creating TABLE "public.instituicao_financeira"
pg_restore: [archiver (db)] Error from TOC entry 1101; 1259 47400590 TABLE instituicao_financeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "instituicao_financeira" already exists
    Command was: CREATE TABLE public.instituicao_financeira (
    seq_instituicao_financeira integer NOT NULL,
    nome character varying(200),
    tipo character varying(20),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    codigo character varying(100)
);



pg_restore: creating SEQUENCE "public.seq_seq_liberacao"
pg_restore: [archiver (db)] Error from TOC entry 1102; 1259 47400594 SEQUENCE seq_seq_liberacao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_seq_liberacao" already exists
    Command was: CREATE SEQUENCE public.seq_seq_liberacao
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.liberacao"
pg_restore: [archiver (db)] Error from TOC entry 1103; 1259 47400596 TABLE liberacao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "liberacao" already exists
    Command was: CREATE TABLE public.liberacao (
    seq_liberacao integer DEFAULT nextval('public.seq_seq_liberacao'::regclass) NOT NULL,
    codigo character varying(100) NOT NULL,
    seq_produto integer NOT NULL,
    status character varying(5),
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    tipo_acesso character varying(20),
    mensagem character varying(50)
);



pg_restore: creating SEQUENCE "public.seq_liberacao_historico"
pg_restore: [archiver (db)] Error from TOC entry 1104; 1259 47400601 SEQUENCE seq_liberacao_historico postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_liberacao_historico" already exists
    Command was: CREATE SEQUENCE public.seq_liberacao_historico
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.liberacao_historico"
pg_restore: [archiver (db)] Error from TOC entry 1105; 1259 47400603 TABLE liberacao_historico postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "liberacao_historico" already exists
    Command was: CREATE TABLE public.liberacao_historico (
    seq_liberacao_historico integer DEFAULT nextval('public.seq_liberacao_historico'::regclass) NOT NULL,
    seq_liberacao integer,
    codigo character varying(100) NOT NULL,
    seq_produto integer,
    status character varying(5),
    data_acesso timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    tipo_acesso character varying(20),
    mensagem character varying(16),
    seq_evento integer
);



pg_restore: creating TABLE "public.matricula"
pg_restore: [archiver (db)] Error from TOC entry 1106; 1259 47400608 TABLE matricula postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "matricula" already exists
    Command was: CREATE TABLE public.matricula (
    matricula integer NOT NULL,
    seq_pessoa integer NOT NULL,
    seq_produto integer NOT NULL,
    seq_cadeira integer,
    seq_camarote integer,
    data_criacao timestamp without time zone,
    data_aquisicao timestamp without time zone,
    data_cancelamento timestamp without time zone,
    dia_cobranca date,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pagador integer,
    em_dia boolean DEFAULT false,
    seq_pessoa_dados_pagamento integer,
    seq_forma_pagamento integer DEFAULT 1 NOT NULL,
    seq_instituicao_financeira integer,
    cob_conta character varying(100),
    cob_agencia character varying(100),
    cob_numero_cartao character varying(100),
    cob_data_vencimento_cartao date,
    cob_codigo_seguranca_cartao character varying(20),
    cob_cep character varying(30),
    cob_endereco character varying(200),
    cob_bairro character varying(100),
    cob_cidade character varying(100),
    cob_uf character varying(20),
    cob_pais integer,
    cob_complemento character varying(200),
    cob_numero integer,
    ativa boolean,
    numero_cartao character varying(50),
    seq_vinculado integer,
    seq_plano_pgto integer,
    matricula_acbf character varying(50),
    seq_produto_escolinha_turma integer
);



pg_restore: creating TABLE "public.movimento_cobranca"
pg_restore: [archiver (db)] Error from TOC entry 1107; 1259 47400614 TABLE movimento_cobranca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_cobranca" already exists
    Command was: CREATE TABLE public.movimento_cobranca (
    seq_movimento_cobranca integer NOT NULL,
    matricula integer,
    seq_produto_taxa integer,
    valor_devido numeric(20,5),
    valor_pago numeric(20,5),
    data_vencimento date,
    data_pagamento timestamp without time zone,
    data_cancelamento timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pessoa integer,
    competencia character varying(10)
);



pg_restore: creating SEQUENCE "public.matricula_cobranca_seq_matricula_cobranca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1108; 1259 47400618 SEQUENCE matricula_cobranca_seq_matricula_cobranca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "matricula_cobranca_seq_matricula_cobranca_seq" already exists
    Command was: CREATE SEQUENCE public.matricula_cobranca_seq_matricula_cobranca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.matricula_cobranca_seq_matricula_cobranca_seq"
pg_restore: creating SEQUENCE "public.matricula_matricula_seq"
pg_restore: [archiver (db)] Error from TOC entry 1109; 1259 47400620 SEQUENCE matricula_matricula_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "matricula_matricula_seq" already exists
    Command was: CREATE SEQUENCE public.matricula_matricula_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.matricula_matricula_seq"
pg_restore: creating TABLE "public.meio_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1110; 1259 47400622 TABLE meio_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "meio_pagamento" already exists
    Command was: CREATE TABLE public.meio_pagamento (
    seq_meio_pagamento integer NOT NULL,
    nome character varying(100) NOT NULL,
    cod_integracao character varying(100) NOT NULL,
    seq_forma_pagamento integer NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.meio_pagamento_seq_meio_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1111; 1259 47400627 SEQUENCE meio_pagamento_seq_meio_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "meio_pagamento_seq_meio_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.meio_pagamento_seq_meio_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.meio_pagamento_seq_meio_pagamento_seq"
pg_restore: creating TABLE "public.menu"
pg_restore: [archiver (db)] Error from TOC entry 1112; 1259 47400629 TABLE menu postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "menu" already exists
    Command was: CREATE TABLE public.menu (
    seq_menu integer NOT NULL,
    texto character varying(50),
    objeto integer,
    pai integer,
    icone character varying(50),
    ativo boolean DEFAULT true
);



pg_restore: creating SEQUENCE "public.menu_seq_menu_seq"
pg_restore: [archiver (db)] Error from TOC entry 1113; 1259 47400633 SEQUENCE menu_seq_menu_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "menu_seq_menu_seq" already exists
    Command was: CREATE SEQUENCE public.menu_seq_menu_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.menu_seq_menu_seq"
pg_restore: creating TABLE "public.movimento"
pg_restore: [archiver (db)] Error from TOC entry 1114; 1259 47400635 TABLE movimento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento" already exists
    Command was: CREATE TABLE public.movimento (
    seq_movimento integer NOT NULL,
    data_criacao timestamp without time zone DEFAULT now(),
    data_pagamento timestamp without time zone,
    valor_total numeric(20,5),
    caixa integer,
    data_estorno timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pessoa integer,
    operador integer
);



pg_restore: creating TABLE "public.movimento_item"
pg_restore: [archiver (db)] Error from TOC entry 1115; 1259 47400640 TABLE movimento_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_item" already exists
    Command was: CREATE TABLE public.movimento_item (
    seq_movimento_item integer NOT NULL,
    seq_produto_taxa integer,
    seq_movimento integer NOT NULL,
    valor_devido numeric(20,5),
    seq_movimento_cobranca integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_sessao_evento_produto integer,
    qtde numeric(30,5)
);



pg_restore: creating SEQUENCE "public.movimento_item_seq_movimento_item_seq"
pg_restore: [archiver (db)] Error from TOC entry 1116; 1259 47400644 SEQUENCE movimento_item_seq_movimento_item_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_item_seq_movimento_item_seq" already exists
    Command was: CREATE SEQUENCE public.movimento_item_seq_movimento_item_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.movimento_item_seq_movimento_item_seq"
pg_restore: creating TABLE "public.movimento_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1117; 1259 47400646 TABLE movimento_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_pagamento" already exists
    Command was: CREATE TABLE public.movimento_pagamento (
    seq_movimento_pagamento integer NOT NULL,
    seq_movimento integer NOT NULL,
    valor_pago numeric(20,5),
    data_pagamento timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_meio_pagamento integer,
    seq_forma_pagamento integer
);



pg_restore: creating SEQUENCE "public.movimento_pagamento_seq_movimento_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1118; 1259 47400650 SEQUENCE movimento_pagamento_seq_movimento_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_pagamento_seq_movimento_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.movimento_pagamento_seq_movimento_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.movimento_pagamento_seq_movimento_pagamento_seq"
pg_restore: creating SEQUENCE "public.movimento_seq_movimento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1119; 1259 47400652 SEQUENCE movimento_seq_movimento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_seq_movimento_seq" already exists
    Command was: CREATE SEQUENCE public.movimento_seq_movimento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.movimento_seq_movimento_seq"
pg_restore: creating TABLE "public.objeto"
pg_restore: [archiver (db)] Error from TOC entry 1120; 1259 47400654 TABLE objeto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "objeto" already exists
    Command was: CREATE TABLE public.objeto (
    seq_objeto integer NOT NULL,
    nome character varying(200) NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    controller character varying(50),
    view character varying(50),
    grupo character varying(50)
);



pg_restore: creating SEQUENCE "public.objeto_seq_objeto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1121; 1259 47400659 SEQUENCE objeto_seq_objeto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "objeto_seq_objeto_seq" already exists
    Command was: CREATE SEQUENCE public.objeto_seq_objeto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.objeto_seq_objeto_seq"
pg_restore: creating TABLE "public.obs_matricula"
pg_restore: [archiver (db)] Error from TOC entry 1122; 1259 47400661 TABLE obs_matricula postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "obs_matricula" already exists
    Command was: CREATE TABLE public.obs_matricula (
    seq_obs_matricula integer NOT NULL,
    matricula integer NOT NULL,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    lido boolean
);



pg_restore: creating SEQUENCE "public.obs_matricula_matricula_seq"
pg_restore: [archiver (db)] Error from TOC entry 1123; 1259 47400668 SEQUENCE obs_matricula_matricula_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "obs_matricula_matricula_seq" already exists
    Command was: CREATE SEQUENCE public.obs_matricula_matricula_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.obs_matricula_matricula_seq"
pg_restore: creating SEQUENCE "public.obs_matricula_seq_obs_matricula_seq"
pg_restore: [archiver (db)] Error from TOC entry 1124; 1259 47400670 SEQUENCE obs_matricula_seq_obs_matricula_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "obs_matricula_seq_obs_matricula_seq" already exists
    Command was: CREATE SEQUENCE public.obs_matricula_seq_obs_matricula_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.obs_matricula_seq_obs_matricula_seq"
pg_restore: creating TABLE "public.pais"
pg_restore: [archiver (db)] Error from TOC entry 1125; 1259 47400672 TABLE pais postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pais" already exists
    Command was: CREATE TABLE public.pais (
    seq_pais integer NOT NULL,
    nome character varying(50)
);



pg_restore: creating SEQUENCE "public.pais_seq_pais_seq"
pg_restore: [archiver (db)] Error from TOC entry 1126; 1259 47400675 SEQUENCE pais_seq_pais_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pais_seq_pais_seq" already exists
    Command was: CREATE SEQUENCE public.pais_seq_pais_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pais_seq_pais_seq"
pg_restore: creating TABLE "public.perfil"
pg_restore: [archiver (db)] Error from TOC entry 1127; 1259 47400677 TABLE perfil postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil" already exists
    Command was: CREATE TABLE public.perfil (
    seq_perfil integer NOT NULL,
    nome character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating TABLE "public.perfil_objeto"
pg_restore: [archiver (db)] Error from TOC entry 1128; 1259 47400681 TABLE perfil_objeto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil_objeto" already exists
    Command was: CREATE TABLE public.perfil_objeto (
    seq_perfil_objeto integer NOT NULL,
    seq_objeto integer NOT NULL,
    seq_perfil integer NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.perfil_objeto_seq_perfil_objeto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1129; 1259 47400686 SEQUENCE perfil_objeto_seq_perfil_objeto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil_objeto_seq_perfil_objeto_seq" already exists
    Command was: CREATE SEQUENCE public.perfil_objeto_seq_perfil_objeto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.perfil_objeto_seq_perfil_objeto_seq"
pg_restore: creating SEQUENCE "public.perfil_seq_perfil_seq"
pg_restore: [archiver (db)] Error from TOC entry 1130; 1259 47400688 SEQUENCE perfil_seq_perfil_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil_seq_perfil_seq" already exists
    Command was: CREATE SEQUENCE public.perfil_seq_perfil_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.perfil_seq_perfil_seq"
pg_restore: creating TABLE "public.pessoa"
pg_restore: [archiver (db)] Error from TOC entry 1131; 1259 47400690 TABLE pessoa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa" already exists
    Command was: CREATE TABLE public.pessoa (
    seq_pessoa integer NOT NULL,
    nome character varying(200) NOT NULL,
    seq_titular integer,
    seq_profissao integer,
    cpf character varying(50) NOT NULL,
    cpf_proprio boolean DEFAULT true,
    rg character varying(50),
    rg_proprio boolean DEFAULT true,
    cep character varying(30) NOT NULL,
    fone_residencial character varying(30),
    ddd_residencial character varying(10),
    fone_celular character varying(30),
    ddd_celular character varying(10),
    fone_comercial character varying(30),
    ddd_comercial character varying(10),
    data_nascimento timestamp without time zone,
    data_falecimento timestamp without time zone,
    sexo character varying(1) DEFAULT 'M'::character varying,
    estado_civil character varying(1) DEFAULT 'S'::character varying,
    email character varying(200),
    escolaridade integer DEFAULT 1,
    faixa_salarial integer DEFAULT 1,
    renda_familiar integer DEFAULT 1,
    casa integer DEFAULT 1,
    nro_filhos integer DEFAULT 1,
    nro_automoveis integer DEFAULT 1,
    nro_televisoes integer DEFAULT 1,
    nro_telefones integer DEFAULT 1,
    nro_celulares integer DEFAULT 1,
    nro_computadores integer DEFAULT 1,
    senha_md5 character varying(100),
    senha_tmp character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    endereco character varying(100),
    numero character varying(10),
    complemento character varying(200),
    bairro character varying(100),
    cidade character varying(100),
    estado character varying(2),
    pais integer,
    cnpj character varying(50),
    juridica boolean DEFAULT false,
    seq_pessoa_acbf integer
);



pg_restore: creating TABLE "public.pessoa_dados_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1132; 1259 47400709 TABLE pessoa_dados_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_dados_pagamento" already exists
    Command was: CREATE TABLE public.pessoa_dados_pagamento (
    seq_pessoa_dados_pagamento integer NOT NULL,
    seq_pessoa integer NOT NULL,
    seq_forma_pagamento integer NOT NULL,
    seq_instituicao_financeira integer,
    cob_conta character varying(100),
    cob_agencia character varying(100),
    cob_numero_cartao character varying(100),
    cob_data_vencimento_cartao date,
    cob_codigo_seguranca_cartao character varying(20),
    cob_cep character varying(30),
    cob_endereco character varying(200),
    cob_bairro character varying(100),
    cob_cidade character varying(100),
    cob_uf character varying(20),
    cob_pais integer,
    usuario_alteracao character varying(100)
);



pg_restore: creating SEQUENCE "public.pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1133; 1259 47400712 SEQUENCE pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq"
pg_restore: creating SEQUENCE "public.pessoa_seq_pessoa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1134; 1259 47400714 SEQUENCE pessoa_seq_pessoa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_seq_pessoa_seq" already exists
    Command was: CREATE SEQUENCE public.pessoa_seq_pessoa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pessoa_seq_pessoa_seq"
pg_restore: creating TABLE "public.pessoa_vinculo"
pg_restore: [archiver (db)] Error from TOC entry 1135; 1259 47400716 TABLE pessoa_vinculo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_vinculo" already exists
    Command was: CREATE TABLE public.pessoa_vinculo (
    seq_pessoa_vinculo integer NOT NULL,
    seq_pessoa integer,
    seq_vinculo integer,
    data_inicio date,
    data_fim date,
    obs character varying(200),
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.pessoa_vinculo_seq_pessoa_vinculo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1136; 1259 47400721 SEQUENCE pessoa_vinculo_seq_pessoa_vinculo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_vinculo_seq_pessoa_vinculo_seq" already exists
    Command was: CREATE SEQUENCE public.pessoa_vinculo_seq_pessoa_vinculo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pessoa_vinculo_seq_pessoa_vinculo_seq"
pg_restore: creating TABLE "public.plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 1137; 1259 47400723 TABLE plano_pgto acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "plano_pgto" already exists
    Command was: CREATE TABLE public.plano_pgto (
    seq_plano_pgto integer NOT NULL,
    seq_produto integer NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: [archiver (db)] could not execute query: ERROR:  role "acbf" does not exist
    Command was: ALTER TABLE public.plano_pgto OWNER TO acbf;


pg_restore: creating SEQUENCE "public.plano_pgto_seq_plano_pgto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1138; 1259 47400727 SEQUENCE plano_pgto_seq_plano_pgto_seq acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "plano_pgto_seq_plano_pgto_seq" already exists
    Command was: CREATE SEQUENCE public.plano_pgto_seq_plano_pgto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: [archiver (db)] could not execute query: ERROR:  role "acbf" does not exist
    Command was: ALTER TABLE public.plano_pgto_seq_plano_pgto_seq OWNER TO acbf;


pg_restore: creating SEQUENCE OWNED BY "public.plano_pgto_seq_plano_pgto_seq"
pg_restore: creating TABLE "public.portao"
pg_restore: [archiver (db)] Error from TOC entry 1139; 1259 47400729 TABLE portao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "portao" already exists
    Command was: CREATE TABLE public.portao (
    seq_portao integer NOT NULL,
    seq_setor integer,
    portao character varying(100) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.portao_seq_portao_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1140; 1259 47400733 SEQUENCE portao_seq_portao_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "portao_seq_portao_seq_1" already exists
    Command was: CREATE SEQUENCE public.portao_seq_portao_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.portao_seq_portao_seq_1"
pg_restore: creating TABLE "public.produto"
pg_restore: [archiver (db)] Error from TOC entry 1141; 1259 47400735 TABLE produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto" already exists
    Command was: CREATE TABLE public.produto (
    seq_produto integer NOT NULL,
    seq_produto_contrato integer,
    produto character varying(200),
    seq_produto_classe integer,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    descricao text,
    tipo character varying(100),
    seq_produto_configuracao integer
);



pg_restore: creating TABLE "public.produto_catraca"
pg_restore: [archiver (db)] Error from TOC entry 1142; 1259 47400742 TABLE produto_catraca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_catraca" already exists
    Command was: CREATE TABLE public.produto_catraca (
    seq_produto_catraca integer NOT NULL,
    seq_catraca integer NOT NULL,
    seq_produto integer NOT NULL,
    status character varying(10),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.produto_catraca_seq_produto_catraca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1143; 1259 47400746 SEQUENCE produto_catraca_seq_produto_catraca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_catraca_seq_produto_catraca_seq" already exists
    Command was: CREATE SEQUENCE public.produto_catraca_seq_produto_catraca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_catraca_seq_produto_catraca_seq"
pg_restore: creating TABLE "public.produto_classe"
pg_restore: [archiver (db)] Error from TOC entry 1144; 1259 47400748 TABLE produto_classe postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_classe" already exists
    Command was: CREATE TABLE public.produto_classe (
    seq_produto_classe integer NOT NULL,
    classe character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.produto_classe_seq_produto_classe_seq"
pg_restore: [archiver (db)] Error from TOC entry 1145; 1259 47400752 SEQUENCE produto_classe_seq_produto_classe_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_classe_seq_produto_classe_seq" already exists
    Command was: CREATE SEQUENCE public.produto_classe_seq_produto_classe_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_classe_seq_produto_classe_seq"
pg_restore: creating TABLE "public.produto_configuracao"
pg_restore: [archiver (db)] Error from TOC entry 1146; 1259 47400754 TABLE produto_configuracao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_configuracao" already exists
    Command was: CREATE TABLE public.produto_configuracao (
    seq_produto_configuracao integer NOT NULL,
    cadeira boolean NOT NULL,
    camarote boolean NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    casal boolean DEFAULT false NOT NULL
);



pg_restore: creating SEQUENCE "public.produto_configuracao_seq_produto_configuracao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1147; 1259 47400759 SEQUENCE produto_configuracao_seq_produto_configuracao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_configuracao_seq_produto_configuracao_seq" already exists
    Command was: CREATE SEQUENCE public.produto_configuracao_seq_produto_configuracao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_configuracao_seq_produto_configuracao_seq"
pg_restore: creating TABLE "public.produto_contrato"
pg_restore: [archiver (db)] Error from TOC entry 1148; 1259 47400761 TABLE produto_contrato postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_contrato" already exists
    Command was: CREATE TABLE public.produto_contrato (
    seq_produto_contrato integer NOT NULL,
    contrato text NOT NULL,
    data_inicio timestamp without time zone NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    titulo character varying(100)
);



pg_restore: creating SEQUENCE "public.produto_contrato_seq_produto_contrato_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1149; 1259 47400768 SEQUENCE produto_contrato_seq_produto_contrato_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_contrato_seq_produto_contrato_seq_1" already exists
    Command was: CREATE SEQUENCE public.produto_contrato_seq_produto_contrato_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_contrato_seq_produto_contrato_seq_1"
pg_restore: creating TABLE "public.produto_escolinha_turma"
pg_restore: [archiver (db)] Error from TOC entry 1192; 1259 49893175 TABLE produto_escolinha_turma postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_escolinha_turma" already exists
    Command was: CREATE TABLE public.produto_escolinha_turma (
    seq_produto_escolinha_turma integer NOT NULL,
    seq_produto integer NOT NULL,
    nome character varying(100),
    vagas integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.produto_escolinha_turma_seq_produto_escolinha_turma_seq"
pg_restore: [archiver (db)] Error from TOC entry 1191; 1259 49893173 SEQUENCE produto_escolinha_turma_seq_produto_escolinha_turma_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_escolinha_turma_seq_produto_escolinha_turma_seq" already exists
    Command was: CREATE SEQUENCE public.produto_escolinha_turma_seq_produto_escolinha_turma_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_escolinha_turma_seq_produto_escolinha_turma_seq"
pg_restore: creating TABLE "public.produto_plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 1150; 1259 47400770 TABLE produto_plano_pgto acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_plano_pgto" already exists
    Command was: CREATE TABLE public.produto_plano_pgto (
    seq_produto_plano_pgto integer NOT NULL,
    seq_plano_pgto integer NOT NULL,
    seq_produto_taxa integer NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_pessoa integer,
    operador integer
);



pg_restore: creating TABLE "public.movimento_item"
pg_restore: [archiver (db)] Error from TOC entry 1115; 1259 47400640 TABLE movimento_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_item" already exists
    Command was: CREATE TABLE public.movimento_item (
    seq_movimento_item integer NOT NULL,
    seq_produto_taxa integer,
    seq_movimento integer NOT NULL,
    valor_devido numeric(20,5),
    seq_movimento_cobranca integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_sessao_evento_produto integer,
    qtde numeric(30,5)
);



pg_restore: creating SEQUENCE "public.movimento_item_seq_movimento_item_seq"
pg_restore: [archiver (db)] Error from TOC entry 1116; 1259 47400644 SEQUENCE movimento_item_seq_movimento_item_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_item_seq_movimento_item_seq" already exists
    Command was: CREATE SEQUENCE public.movimento_item_seq_movimento_item_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.movimento_item_seq_movimento_item_seq"
pg_restore: creating TABLE "public.movimento_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1117; 1259 47400646 TABLE movimento_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_pagamento" already exists
    Command was: CREATE TABLE public.movimento_pagamento (
    seq_movimento_pagamento integer NOT NULL,
    seq_movimento integer NOT NULL,
    valor_pago numeric(20,5),
    data_pagamento timestamp without time zone,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    seq_meio_pagamento integer,
    seq_forma_pagamento integer
);



pg_restore: creating SEQUENCE "public.movimento_pagamento_seq_movimento_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1118; 1259 47400650 SEQUENCE movimento_pagamento_seq_movimento_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_pagamento_seq_movimento_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.movimento_pagamento_seq_movimento_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.movimento_pagamento_seq_movimento_pagamento_seq"
pg_restore: creating SEQUENCE "public.movimento_seq_movimento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1119; 1259 47400652 SEQUENCE movimento_seq_movimento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "movimento_seq_movimento_seq" already exists
    Command was: CREATE SEQUENCE public.movimento_seq_movimento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.movimento_seq_movimento_seq"
pg_restore: creating TABLE "public.objeto"
pg_restore: [archiver (db)] Error from TOC entry 1120; 1259 47400654 TABLE objeto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "objeto" already exists
    Command was: CREATE TABLE public.objeto (
    seq_objeto integer NOT NULL,
    nome character varying(200) NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    controller character varying(50),
    view character varying(50),
    grupo character varying(50)
);



pg_restore: creating SEQUENCE "public.objeto_seq_objeto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1121; 1259 47400659 SEQUENCE objeto_seq_objeto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "objeto_seq_objeto_seq" already exists
    Command was: CREATE SEQUENCE public.objeto_seq_objeto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.objeto_seq_objeto_seq"
pg_restore: creating TABLE "public.obs_matricula"
pg_restore: [archiver (db)] Error from TOC entry 1122; 1259 47400661 TABLE obs_matricula postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "obs_matricula" already exists
    Command was: CREATE TABLE public.obs_matricula (
    seq_obs_matricula integer NOT NULL,
    matricula integer NOT NULL,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    lido boolean
);



pg_restore: creating SEQUENCE "public.obs_matricula_matricula_seq"
pg_restore: [archiver (db)] Error from TOC entry 1123; 1259 47400668 SEQUENCE obs_matricula_matricula_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "obs_matricula_matricula_seq" already exists
    Command was: CREATE SEQUENCE public.obs_matricula_matricula_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.obs_matricula_matricula_seq"
pg_restore: creating SEQUENCE "public.obs_matricula_seq_obs_matricula_seq"
pg_restore: [archiver (db)] Error from TOC entry 1124; 1259 47400670 SEQUENCE obs_matricula_seq_obs_matricula_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "obs_matricula_seq_obs_matricula_seq" already exists
    Command was: CREATE SEQUENCE public.obs_matricula_seq_obs_matricula_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.obs_matricula_seq_obs_matricula_seq"
pg_restore: creating TABLE "public.pais"
pg_restore: [archiver (db)] Error from TOC entry 1125; 1259 47400672 TABLE pais postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pais" already exists
    Command was: CREATE TABLE public.pais (
    seq_pais integer NOT NULL,
    nome character varying(50)
);



pg_restore: creating SEQUENCE "public.pais_seq_pais_seq"
pg_restore: [archiver (db)] Error from TOC entry 1126; 1259 47400675 SEQUENCE pais_seq_pais_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pais_seq_pais_seq" already exists
    Command was: CREATE SEQUENCE public.pais_seq_pais_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pais_seq_pais_seq"
pg_restore: creating TABLE "public.perfil"
pg_restore: [archiver (db)] Error from TOC entry 1127; 1259 47400677 TABLE perfil postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil" already exists
    Command was: CREATE TABLE public.perfil (
    seq_perfil integer NOT NULL,
    nome character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating TABLE "public.perfil_objeto"
pg_restore: [archiver (db)] Error from TOC entry 1128; 1259 47400681 TABLE perfil_objeto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil_objeto" already exists
    Command was: CREATE TABLE public.perfil_objeto (
    seq_perfil_objeto integer NOT NULL,
    seq_objeto integer NOT NULL,
    seq_perfil integer NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.perfil_objeto_seq_perfil_objeto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1129; 1259 47400686 SEQUENCE perfil_objeto_seq_perfil_objeto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil_objeto_seq_perfil_objeto_seq" already exists
    Command was: CREATE SEQUENCE public.perfil_objeto_seq_perfil_objeto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.perfil_objeto_seq_perfil_objeto_seq"
pg_restore: creating SEQUENCE "public.perfil_seq_perfil_seq"
pg_restore: [archiver (db)] Error from TOC entry 1130; 1259 47400688 SEQUENCE perfil_seq_perfil_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "perfil_seq_perfil_seq" already exists
    Command was: CREATE SEQUENCE public.perfil_seq_perfil_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.perfil_seq_perfil_seq"
pg_restore: creating TABLE "public.pessoa"
pg_restore: [archiver (db)] Error from TOC entry 1131; 1259 47400690 TABLE pessoa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa" already exists
    Command was: CREATE TABLE public.pessoa (
    seq_pessoa integer NOT NULL,
    nome character varying(200) NOT NULL,
    seq_titular integer,
    seq_profissao integer,
    cpf character varying(50) NOT NULL,
    cpf_proprio boolean DEFAULT true,
    rg character varying(50),
    rg_proprio boolean DEFAULT true,
    cep character varying(30) NOT NULL,
    fone_residencial character varying(30),
    ddd_residencial character varying(10),
    fone_celular character varying(30),
    ddd_celular character varying(10),
    fone_comercial character varying(30),
    ddd_comercial character varying(10),
    data_nascimento timestamp without time zone,
    data_falecimento timestamp without time zone,
    sexo character varying(1) DEFAULT 'M'::character varying,
    estado_civil character varying(1) DEFAULT 'S'::character varying,
    email character varying(200),
    escolaridade integer DEFAULT 1,
    faixa_salarial integer DEFAULT 1,
    renda_familiar integer DEFAULT 1,
    casa integer DEFAULT 1,
    nro_filhos integer DEFAULT 1,
    nro_automoveis integer DEFAULT 1,
    nro_televisoes integer DEFAULT 1,
    nro_telefones integer DEFAULT 1,
    nro_celulares integer DEFAULT 1,
    nro_computadores integer DEFAULT 1,
    senha_md5 character varying(100),
    senha_tmp character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    endereco character varying(100),
    numero character varying(10),
    complemento character varying(200),
    bairro character varying(100),
    cidade character varying(100),
    estado character varying(2),
    pais integer,
    cnpj character varying(50),
    juridica boolean DEFAULT false,
    seq_pessoa_acbf integer
);



pg_restore: creating TABLE "public.pessoa_dados_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 1132; 1259 47400709 TABLE pessoa_dados_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_dados_pagamento" already exists
    Command was: CREATE TABLE public.pessoa_dados_pagamento (
    seq_pessoa_dados_pagamento integer NOT NULL,
    seq_pessoa integer NOT NULL,
    seq_forma_pagamento integer NOT NULL,
    seq_instituicao_financeira integer,
    cob_conta character varying(100),
    cob_agencia character varying(100),
    cob_numero_cartao character varying(100),
    cob_data_vencimento_cartao date,
    cob_codigo_seguranca_cartao character varying(20),
    cob_cep character varying(30),
    cob_endereco character varying(200),
    cob_bairro character varying(100),
    cob_cidade character varying(100),
    cob_uf character varying(20),
    cob_pais integer,
    usuario_alteracao character varying(100)
);



pg_restore: creating SEQUENCE "public.pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq"
pg_restore: [archiver (db)] Error from TOC entry 1133; 1259 47400712 SEQUENCE pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq" already exists
    Command was: CREATE SEQUENCE public.pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq"
pg_restore: creating SEQUENCE "public.pessoa_seq_pessoa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1134; 1259 47400714 SEQUENCE pessoa_seq_pessoa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_seq_pessoa_seq" already exists
    Command was: CREATE SEQUENCE public.pessoa_seq_pessoa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pessoa_seq_pessoa_seq"
pg_restore: creating TABLE "public.pessoa_vinculo"
pg_restore: [archiver (db)] Error from TOC entry 1135; 1259 47400716 TABLE pessoa_vinculo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_vinculo" already exists
    Command was: CREATE TABLE public.pessoa_vinculo (
    seq_pessoa_vinculo integer NOT NULL,
    seq_pessoa integer,
    seq_vinculo integer,
    data_inicio date,
    data_fim date,
    obs character varying(200),
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.pessoa_vinculo_seq_pessoa_vinculo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1136; 1259 47400721 SEQUENCE pessoa_vinculo_seq_pessoa_vinculo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "pessoa_vinculo_seq_pessoa_vinculo_seq" already exists
    Command was: CREATE SEQUENCE public.pessoa_vinculo_seq_pessoa_vinculo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.pessoa_vinculo_seq_pessoa_vinculo_seq"
pg_restore: creating TABLE "public.plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 1137; 1259 47400723 TABLE plano_pgto acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "plano_pgto" already exists
    Command was: CREATE TABLE public.plano_pgto (
    seq_plano_pgto integer NOT NULL,
    seq_produto integer NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: [archiver (db)] could not execute query: ERROR:  role "acbf" does not exist
    Command was: ALTER TABLE public.plano_pgto OWNER TO acbf;


pg_restore: creating SEQUENCE "public.plano_pgto_seq_plano_pgto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1138; 1259 47400727 SEQUENCE plano_pgto_seq_plano_pgto_seq acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "plano_pgto_seq_plano_pgto_seq" already exists
    Command was: CREATE SEQUENCE public.plano_pgto_seq_plano_pgto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: [archiver (db)] could not execute query: ERROR:  role "acbf" does not exist
    Command was: ALTER TABLE public.plano_pgto_seq_plano_pgto_seq OWNER TO acbf;


pg_restore: creating SEQUENCE OWNED BY "public.plano_pgto_seq_plano_pgto_seq"
pg_restore: creating TABLE "public.portao"
pg_restore: [archiver (db)] Error from TOC entry 1139; 1259 47400729 TABLE portao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "portao" already exists
    Command was: CREATE TABLE public.portao (
    seq_portao integer NOT NULL,
    seq_setor integer,
    portao character varying(100) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.portao_seq_portao_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1140; 1259 47400733 SEQUENCE portao_seq_portao_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "portao_seq_portao_seq_1" already exists
    Command was: CREATE SEQUENCE public.portao_seq_portao_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.portao_seq_portao_seq_1"
pg_restore: creating TABLE "public.produto"
pg_restore: [archiver (db)] Error from TOC entry 1141; 1259 47400735 TABLE produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto" already exists
    Command was: CREATE TABLE public.produto (
    seq_produto integer NOT NULL,
    seq_produto_contrato integer,
    produto character varying(200),
    seq_produto_classe integer,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    descricao text,
    tipo character varying(100),
    seq_produto_configuracao integer
);



pg_restore: creating TABLE "public.produto_catraca"
pg_restore: [archiver (db)] Error from TOC entry 1142; 1259 47400742 TABLE produto_catraca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_catraca" already exists
    Command was: CREATE TABLE public.produto_catraca (
    seq_produto_catraca integer NOT NULL,
    seq_catraca integer NOT NULL,
    seq_produto integer NOT NULL,
    status character varying(10),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.produto_catraca_seq_produto_catraca_seq"
pg_restore: [archiver (db)] Error from TOC entry 1143; 1259 47400746 SEQUENCE produto_catraca_seq_produto_catraca_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_catraca_seq_produto_catraca_seq" already exists
    Command was: CREATE SEQUENCE public.produto_catraca_seq_produto_catraca_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_catraca_seq_produto_catraca_seq"
pg_restore: creating TABLE "public.produto_classe"
pg_restore: [archiver (db)] Error from TOC entry 1144; 1259 47400748 TABLE produto_classe postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_classe" already exists
    Command was: CREATE TABLE public.produto_classe (
    seq_produto_classe integer NOT NULL,
    classe character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.produto_classe_seq_produto_classe_seq"
pg_restore: [archiver (db)] Error from TOC entry 1145; 1259 47400752 SEQUENCE produto_classe_seq_produto_classe_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_classe_seq_produto_classe_seq" already exists
    Command was: CREATE SEQUENCE public.produto_classe_seq_produto_classe_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_classe_seq_produto_classe_seq"
pg_restore: creating TABLE "public.produto_configuracao"
pg_restore: [archiver (db)] Error from TOC entry 1146; 1259 47400754 TABLE produto_configuracao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_configuracao" already exists
    Command was: CREATE TABLE public.produto_configuracao (
    seq_produto_configuracao integer NOT NULL,
    cadeira boolean NOT NULL,
    camarote boolean NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    casal boolean DEFAULT false NOT NULL
);



pg_restore: creating SEQUENCE "public.produto_configuracao_seq_produto_configuracao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1147; 1259 47400759 SEQUENCE produto_configuracao_seq_produto_configuracao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_configuracao_seq_produto_configuracao_seq" already exists
    Command was: CREATE SEQUENCE public.produto_configuracao_seq_produto_configuracao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_configuracao_seq_produto_configuracao_seq"
pg_restore: creating TABLE "public.produto_contrato"
pg_restore: [archiver (db)] Error from TOC entry 1148; 1259 47400761 TABLE produto_contrato postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_contrato" already exists
    Command was: CREATE TABLE public.produto_contrato (
    seq_produto_contrato integer NOT NULL,
    contrato text NOT NULL,
    data_inicio timestamp without time zone NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    titulo character varying(100)
);



pg_restore: creating SEQUENCE "public.produto_contrato_seq_produto_contrato_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1149; 1259 47400768 SEQUENCE produto_contrato_seq_produto_contrato_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_contrato_seq_produto_contrato_seq_1" already exists
    Command was: CREATE SEQUENCE public.produto_contrato_seq_produto_contrato_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_contrato_seq_produto_contrato_seq_1"
pg_restore: creating TABLE "public.produto_escolinha_turma"
pg_restore: [archiver (db)] Error from TOC entry 1192; 1259 49893175 TABLE produto_escolinha_turma postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_escolinha_turma" already exists
    Command was: CREATE TABLE public.produto_escolinha_turma (
    seq_produto_escolinha_turma integer NOT NULL,
    seq_produto integer NOT NULL,
    nome character varying(100),
    vagas integer,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.produto_escolinha_turma_seq_produto_escolinha_turma_seq"
pg_restore: [archiver (db)] Error from TOC entry 1191; 1259 49893173 SEQUENCE produto_escolinha_turma_seq_produto_escolinha_turma_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_escolinha_turma_seq_produto_escolinha_turma_seq" already exists
    Command was: CREATE SEQUENCE public.produto_escolinha_turma_seq_produto_escolinha_turma_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_escolinha_turma_seq_produto_escolinha_turma_seq"
pg_restore: creating TABLE "public.produto_plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 1150; 1259 47400770 TABLE produto_plano_pgto acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_plano_pgto" already exists
    Command was: CREATE TABLE public.produto_plano_pgto (
    seq_produto_plano_pgto integer NOT NULL,
    seq_plano_pgto integer NOT NULL,
    seq_produto_taxa integer NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: [archiver (db)] could not execute query: ERROR:  role "acbf" does not exist
    Command was: ALTER TABLE public.produto_plano_pgto OWNER TO acbf;


pg_restore: creating SEQUENCE "public.produto_plano_pgto_seq_produto_plano_pgto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1151; 1259 47400774 SEQUENCE produto_plano_pgto_seq_produto_plano_pgto_seq acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_plano_pgto_seq_produto_plano_pgto_seq" already exists
    Command was: CREATE SEQUENCE public.produto_plano_pgto_seq_produto_plano_pgto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: [archiver (db)] could not execute query: ERROR:  role "acbf" does not exist
    Command was: ALTER TABLE public.produto_plano_pgto_seq_produto_plano_pgto_seq OWNER TO acbf;


pg_restore: creating SEQUENCE OWNED BY "public.produto_plano_pgto_seq_produto_plano_pgto_seq"
pg_restore: creating SEQUENCE "public.produto_seq_produto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1152; 1259 47400776 SEQUENCE produto_seq_produto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_seq_produto_seq" already exists
    Command was: CREATE SEQUENCE public.produto_seq_produto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_seq_produto_seq"
pg_restore: creating TABLE "public.produto_taxa"
pg_restore: [archiver (db)] Error from TOC entry 1153; 1259 47400778 TABLE produto_taxa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_taxa" already exists
    Command was: CREATE TABLE public.produto_taxa (
    seq_produto_taxa integer NOT NULL,
    seq_produto integer NOT NULL,
    seq_taxa integer NOT NULL,
    ciclico boolean,
    dia_vencimento date,
    desconto_em_dia numeric(20,5),
    valor numeric(20,5),
    numero_vezes integer,
    dias_apos_criacao integer,
    desconto_debito_automatico numeric(20,5),
    dias_apos_primeiro_pagamento integer,
    dias_uteis boolean DEFAULT false NOT NULL,
    obs text,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    periodicidade character varying(100),
    data_inicio_validade date,
    desconto_filho_socio numeric(20,5)
);



pg_restore: creating SEQUENCE "public.produto_taxa_seq_produto_taxa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1154; 1259 47400786 SEQUENCE produto_taxa_seq_produto_taxa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "produto_taxa_seq_produto_taxa_seq" already exists
    Command was: CREATE SEQUENCE public.produto_taxa_seq_produto_taxa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.produto_taxa_seq_produto_taxa_seq"
pg_restore: creating TABLE "public.profissao"
pg_restore: [archiver (db)] Error from TOC entry 1155; 1259 47400788 TABLE profissao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "profissao" already exists
    Command was: CREATE TABLE public.profissao (
    seq_profissao integer NOT NULL,
    profissao character varying(200) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.profissao_seq_profissao_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1156; 1259 47400792 SEQUENCE profissao_seq_profissao_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "profissao_seq_profissao_seq_1" already exists
    Command was: CREATE SEQUENCE public.profissao_seq_profissao_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.profissao_seq_profissao_seq_1"
pg_restore: creating TABLE "public.remessa"
pg_restore: [archiver (db)] Error from TOC entry 1157; 1259 47400794 TABLE remessa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "remessa" already exists
    Command was: CREATE TABLE public.remessa (
    seq_remessa integer NOT NULL,
    descricao character varying(200),
    tipo character varying(50),
    data_vencimento date,
    seq_instituicao_financeira integer,
    sequencia integer,
    competencia character varying(10)
);



pg_restore: creating TABLE "public.remessa_item"
pg_restore: [archiver (db)] Error from TOC entry 1158; 1259 47400797 TABLE remessa_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "remessa_item" already exists
    Command was: CREATE TABLE public.remessa_item (
    seq_remessa_item integer NOT NULL,
    seq_remessa integer,
    data_vencimento date,
    valor_vencimento numeric(10,5),
    data_emissao timestamp without time zone,
    retorno character varying(50),
    data_retorno timestamp without time zone,
    sequencia integer,
    seq_movimento_cobranca integer
);



pg_restore: creating SEQUENCE "public.remessa_item_seq_remessa_item_seq"
pg_restore: [archiver (db)] Error from TOC entry 1159; 1259 47400800 SEQUENCE remessa_item_seq_remessa_item_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "remessa_item_seq_remessa_item_seq" already exists
    Command was: CREATE SEQUENCE public.remessa_item_seq_remessa_item_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.remessa_item_seq_remessa_item_seq"
pg_restore: creating SEQUENCE "public.remessa_seq_remessa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1160; 1259 47400802 SEQUENCE remessa_seq_remessa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "remessa_seq_remessa_seq" already exists
    Command was: CREATE SEQUENCE public.remessa_seq_remessa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.remessa_seq_remessa_seq"
pg_restore: creating TABLE "public.renda_familiar"
pg_restore: [archiver (db)] Error from TOC entry 1161; 1259 47400804 TABLE renda_familiar postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "renda_familiar" already exists
    Command was: CREATE TABLE public.renda_familiar (
    seq_renda_familiar integer NOT NULL,
    descricao character varying(200)
);



pg_restore: creating SEQUENCE "public.renda_familiar_seq_renda_familiar_seq"
pg_restore: [archiver (db)] Error from TOC entry 1162; 1259 47400807 SEQUENCE renda_familiar_seq_renda_familiar_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "renda_familiar_seq_renda_familiar_seq" already exists
    Command was: CREATE SEQUENCE public.renda_familiar_seq_renda_familiar_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.renda_familiar_seq_renda_familiar_seq"
pg_restore: creating TABLE "public.sangria"
pg_restore: [archiver (db)] Error from TOC entry 1163; 1259 47400809 TABLE sangria postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "sangria" already exists
    Command was: CREATE TABLE public.sangria (
    seq_sangria integer NOT NULL,
    seq_sessao integer NOT NULL,
    valor numeric(30,5) NOT NULL,
    seq_supervisor bigint NOT NULL,
    dt_carga timestamp without time zone DEFAULT now() NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.sangria_seq_sangria_seq"
pg_restore: [archiver (db)] Error from TOC entry 1164; 1259 47400814 SEQUENCE sangria_seq_sangria_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "sangria_seq_sangria_seq" already exists
    Command was: CREATE SEQUENCE public.sangria_seq_sangria_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.sangria_seq_sangria_seq"
pg_restore: creating SEQUENCE "public.seq_competencia"
pg_restore: [archiver (db)] Error from TOC entry 1165; 1259 47400816 SEQUENCE seq_competencia postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_competencia" already exists
    Command was: CREATE SEQUENCE public.seq_competencia
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE "public.seq_conta"
pg_restore: [archiver (db)] Error from TOC entry 1166; 1259 47400818 SEQUENCE seq_conta postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_conta" already exists
    Command was: CREATE SEQUENCE public.seq_conta
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE "public.seq_ingresso_numero"
pg_restore: [archiver (db)] Error from TOC entry 1167; 1259 47400820 SEQUENCE seq_ingresso_numero postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_ingresso_numero" already exists
    Command was: CREATE SEQUENCE public.seq_ingresso_numero
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE "public.seq_instituicao_financeira"
pg_restore: [archiver (db)] Error from TOC entry 1168; 1259 47400822 SEQUENCE seq_instituicao_financeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_instituicao_financeira" already exists
    Command was: CREATE SEQUENCE public.seq_instituicao_financeira
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.seq_instituicao_financeira"
pg_restore: creating SEQUENCE "public.seq_nosso_numero"
pg_restore: [archiver (db)] Error from TOC entry 1169; 1259 47400824 SEQUENCE seq_nosso_numero postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_nosso_numero" already exists
    Command was: CREATE SEQUENCE public.seq_nosso_numero
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE "public.seq_voucher"
pg_restore: [archiver (db)] Error from TOC entry 1170; 1259 47400826 SEQUENCE seq_voucher postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "seq_voucher" already exists
    Command was: CREATE SEQUENCE public.seq_voucher
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating TABLE "public.sessao"
pg_restore: [archiver (db)] Error from TOC entry 1171; 1259 47400828 TABLE sessao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "sessao" already exists
    Command was: CREATE TABLE public.sessao (
    seq_sessao integer NOT NULL,
    seq_bilheteria integer NOT NULL,
    dt_abertura timestamp without time zone NOT NULL,
    dt_encerramento timestamp without time zone NOT NULL,
    seq_bilheteiro bigint NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    seq_evento integer
);



pg_restore: creating TABLE "public.sessao_evento_produto"
pg_restore: [archiver (db)] Error from TOC entry 1172; 1259 47400832 TABLE sessao_evento_produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "sessao_evento_produto" already exists
    Command was: CREATE TABLE public.sessao_evento_produto (
    seq_sessao_evento_produto integer NOT NULL,
    seq_sessao integer NOT NULL,
    seq_evento_produto integer NOT NULL,
    qtde integer NOT NULL,
    dt_carga timestamp without time zone DEFAULT now(),
    seq_supervisor bigint,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.sessao_evento_produto_seq_sessao_evento_produto_seq"
pg_restore: [archiver (db)] Error from TOC entry 1173; 1259 47400837 SEQUENCE sessao_evento_produto_seq_sessao_evento_produto_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "sessao_evento_produto_seq_sessao_evento_produto_seq" already exists
    Command was: CREATE SEQUENCE public.sessao_evento_produto_seq_sessao_evento_produto_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.sessao_evento_produto_seq_sessao_evento_produto_seq"
pg_restore: creating SEQUENCE "public.sessao_seq_sessao_seq"
pg_restore: [archiver (db)] Error from TOC entry 1174; 1259 47400839 SEQUENCE sessao_seq_sessao_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "sessao_seq_sessao_seq" already exists
    Command was: CREATE SEQUENCE public.sessao_seq_sessao_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.sessao_seq_sessao_seq"
pg_restore: creating TABLE "public.setor"
pg_restore: [archiver (db)] Error from TOC entry 1175; 1259 47400841 TABLE setor postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "setor" already exists
    Command was: CREATE TABLE public.setor (
    seq_setor integer NOT NULL,
    setor character varying(100) NOT NULL,
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now()
);



pg_restore: creating SEQUENCE "public.setor_seq_setor_seq_1"
pg_restore: [archiver (db)] Error from TOC entry 1176; 1259 47400845 SEQUENCE setor_seq_setor_seq_1 postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "setor_seq_setor_seq_1" already exists
    Command was: CREATE SEQUENCE public.setor_seq_setor_seq_1
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.setor_seq_setor_seq_1"
pg_restore: creating TABLE "public.socio_tmp"
pg_restore: [archiver (db)] Error from TOC entry 1177; 1259 47400847 TABLE socio_tmp postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "socio_tmp" already exists
    Command was: CREATE TABLE public.socio_tmp (
    codigo text,
    nome text
);



pg_restore: creating TABLE "public.taxa"
pg_restore: [archiver (db)] Error from TOC entry 1178; 1259 47400853 TABLE taxa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "taxa" already exists
    Command was: CREATE TABLE public.taxa (
    seq_taxa integer NOT NULL,
    taxa character varying(200),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now(),
    abreviado character varying(100)
);



pg_restore: creating COMMENT "public.TABLE taxa"
pg_restore: creating SEQUENCE "public.taxa_seq_taxa_seq"
pg_restore: [archiver (db)] Error from TOC entry 1179; 1259 47400857 SEQUENCE taxa_seq_taxa_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "taxa_seq_taxa_seq" already exists
    Command was: CREATE SEQUENCE public.taxa_seq_taxa_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.taxa_seq_taxa_seq"
pg_restore: creating TABLE "public.tmp_importacao_socio"
pg_restore: [archiver (db)] Error from TOC entry 1180; 1259 47400859 TABLE tmp_importacao_socio postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "tmp_importacao_socio" already exists
    Command was: CREATE TABLE public.tmp_importacao_socio (
    matricula character varying(100),
    nome character varying(200),
    categoria character varying(100),
    fone character varying(200),
    servico character varying(200),
    ult_pagamento character varying(200)
);



pg_restore: creating TABLE "public.tmp_socio"
pg_restore: [archiver (db)] Error from TOC entry 1181; 1259 47400862 TABLE tmp_socio postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "tmp_socio" already exists
    Command was: CREATE TABLE public.tmp_socio (
    matricula character varying(8),
    nome character varying(35),
    categoria character varying(8)
);



pg_restore: creating TABLE "public.troco"
pg_restore: [archiver (db)] Error from TOC entry 1182; 1259 47400865 TABLE troco postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "troco" already exists
    Command was: CREATE TABLE public.troco (
    seq_troco integer NOT NULL,
    seq_sessao integer NOT NULL,
    valor numeric(30,5) NOT NULL,
    seq_supervisor bigint NOT NULL,
    dt_carga timestamp without time zone DEFAULT now() NOT NULL,
    usuario_alteracao character varying(100) NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.troco_seq_troco_seq"
pg_restore: [archiver (db)] Error from TOC entry 1183; 1259 47400870 SEQUENCE troco_seq_troco_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "troco_seq_troco_seq" already exists
    Command was: CREATE SEQUENCE public.troco_seq_troco_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.troco_seq_troco_seq"
pg_restore: creating TABLE "public.usuario"
pg_restore: [archiver (db)] Error from TOC entry 1184; 1259 47400872 TABLE usuario postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "usuario" already exists
    Command was: CREATE TABLE public.usuario (
    seq_usuario integer NOT NULL,
    login character varying(100),
    senha_md5 character varying(200),
    ativo boolean DEFAULT true NOT NULL,
    seq_usuario_tipo integer NOT NULL,
    bloqueado boolean DEFAULT false NOT NULL,
    seq_pessoa integer,
    seq_perfil integer NOT NULL,
    dt_expira date,
    email character varying(100),
    nome character varying(100) NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.usuario_seq_usuario_seq"
pg_restore: [archiver (db)] Error from TOC entry 1185; 1259 47400879 SEQUENCE usuario_seq_usuario_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "usuario_seq_usuario_seq" already exists
    Command was: CREATE SEQUENCE public.usuario_seq_usuario_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.usuario_seq_usuario_seq"
pg_restore: creating TABLE "public.usuario_tipo"
pg_restore: [archiver (db)] Error from TOC entry 1186; 1259 47400881 TABLE usuario_tipo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "usuario_tipo" already exists
    Command was: CREATE TABLE public.usuario_tipo (
    seq_usuario_tipo integer NOT NULL,
    descricao character varying(100) NOT NULL,
    usuario_alteracao character varying(100) DEFAULT 'golway'::character varying NOT NULL,
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL
);



pg_restore: creating SEQUENCE "public.usuario_tipo_seq_usuario_tipo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1187; 1259 47400886 SEQUENCE usuario_tipo_seq_usuario_tipo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "usuario_tipo_seq_usuario_tipo_seq" already exists
    Command was: CREATE SEQUENCE public.usuario_tipo_seq_usuario_tipo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.usuario_tipo_seq_usuario_tipo_seq"
pg_restore: creating TABLE "public.vinculo"
pg_restore: [archiver (db)] Error from TOC entry 1188; 1259 47400888 TABLE vinculo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "vinculo" already exists
    Command was: CREATE TABLE public.vinculo (
    seq_vinculo integer NOT NULL,
    nome character varying(200),
    data_alteracao timestamp(0) without time zone DEFAULT now(),
    usuario_alteracao character varying(100)
);



pg_restore: creating SEQUENCE "public.vinculo_seq_vinculo_seq"
pg_restore: [archiver (db)] Error from TOC entry 1189; 1259 47400892 SEQUENCE vinculo_seq_vinculo_seq postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "vinculo_seq_vinculo_seq" already exists
    Command was: CREATE SEQUENCE public.vinculo_seq_vinculo_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;



pg_restore: creating SEQUENCE OWNED BY "public.vinculo_seq_vinculo_seq"
pg_restore: creating TABLE "public.voucher"
pg_restore: [archiver (db)] Error from TOC entry 1190; 1259 47400894 TABLE voucher postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "voucher" already exists
    Command was: CREATE TABLE public.voucher (
    seq_voucher integer DEFAULT nextval('public.seq_voucher'::regclass) NOT NULL,
    codigo_web character varying(100),
    codigo_barras character varying(100) NOT NULL,
    nome character varying(100),
    documento character varying(100),
    email character varying(100),
    data_troca timestamp without time zone,
    seq_produto integer,
    produto character varying(100),
    seq_evento integer,
    evento character varying(100),
    usuario_alteracao character varying(100),
    data_alteracao timestamp without time zone DEFAULT now() NOT NULL,
    seq_pessoa integer,
    seq_sessao_evento_produto integer
);



pg_restore: creating DEFAULT "public.acesso seq_acesso"
pg_restore: creating DEFAULT "public.acesso_historico seq_acesso_historico"
pg_restore: creating DEFAULT "public.assento seq_assento"
pg_restore: creating DEFAULT "public.baixa seq_baixa"
pg_restore: creating DEFAULT "public.bilheteria seq_bilheteria"
pg_restore: creating DEFAULT "public.boleto_macro seq_boleto_macro"
pg_restore: creating DEFAULT "public.cadeira seq_cadeira"
pg_restore: creating DEFAULT "public.camarote seq_camarote"
pg_restore: creating DEFAULT "public.catraca seq_catraca"
pg_restore: creating DEFAULT "public.clube seq_clube"
pg_restore: creating DEFAULT "public.cobranca seq_cobranca"
pg_restore: creating DEFAULT "public.cobranca_retorno seq_cobranca_retorno"
pg_restore: creating DEFAULT "public.cobranca_titulo seq_cobranca_titulo"
pg_restore: creating DEFAULT "public.cobranca_titulo_item seq_cobranca_titulo_item"
pg_restore: creating DEFAULT "public.competicao seq_competicao"
pg_restore: creating DEFAULT "public.competicao_edicao seq_competicao_edicao"
pg_restore: creating DEFAULT "public.dne seq_dne"
pg_restore: creating DEFAULT "public.escolaridade seq_escolaridade"
pg_restore: creating DEFAULT "public.estado seq_estado"
pg_restore: creating DEFAULT "public.evento seq_evento"
pg_restore: creating DEFAULT "public.evento_local seq_evento_local"
pg_restore: creating DEFAULT "public.evento_objetivo seq_evento_objetivo"
pg_restore: creating DEFAULT "public.evento_produto seq_evento_produto"
pg_restore: creating DEFAULT "public.faixa_salarial seq_faixa_salarial"
pg_restore: creating DEFAULT "public.forma_pagamento seq_forma_pagamento"
pg_restore: creating DEFAULT "public.ingresso seq_ingresso"
pg_restore: creating DEFAULT "public.instituicao_financeira seq_instituicao_financeira"
pg_restore: creating DEFAULT "public.meio_pagamento seq_meio_pagamento"
pg_restore: creating DEFAULT "public.menu seq_menu"
pg_restore: creating DEFAULT "public.movimento seq_movimento"
pg_restore: creating DEFAULT "public.movimento_cobranca seq_movimento_cobranca"
pg_restore: creating DEFAULT "public.movimento_item seq_movimento_item"
pg_restore: creating DEFAULT "public.movimento_pagamento seq_movimento_pagamento"
pg_restore: creating DEFAULT "public.objeto seq_objeto"
pg_restore: creating DEFAULT "public.obs_matricula seq_obs_matricula"
pg_restore: creating DEFAULT "public.obs_matricula matricula"
pg_restore: creating DEFAULT "public.pais seq_pais"
pg_restore: creating DEFAULT "public.perfil seq_perfil"
pg_restore: creating DEFAULT "public.perfil_objeto seq_perfil_objeto"
pg_restore: creating DEFAULT "public.pessoa seq_pessoa"
pg_restore: creating DEFAULT "public.pessoa_dados_pagamento seq_pessoa_dados_pagamento"
pg_restore: creating DEFAULT "public.pessoa_vinculo seq_pessoa_vinculo"
pg_restore: creating DEFAULT "public.plano_pgto seq_plano_pgto"
pg_restore: creating DEFAULT "public.portao seq_portao"
pg_restore: creating DEFAULT "public.produto seq_produto"
pg_restore: creating DEFAULT "public.produto_catraca seq_produto_catraca"
pg_restore: creating DEFAULT "public.produto_classe seq_produto_classe"
pg_restore: creating DEFAULT "public.produto_configuracao seq_produto_configuracao"
pg_restore: creating DEFAULT "public.produto_contrato seq_produto_contrato"
pg_restore: creating DEFAULT "public.produto_escolinha_turma seq_produto_escolinha_turma"
pg_restore: creating DEFAULT "public.produto_plano_pgto seq_produto_plano_pgto"
pg_restore: creating DEFAULT "public.produto_taxa seq_produto_taxa"
pg_restore: creating DEFAULT "public.profissao seq_profissao"
pg_restore: creating DEFAULT "public.remessa seq_remessa"
pg_restore: creating DEFAULT "public.remessa_item seq_remessa_item"
pg_restore: creating DEFAULT "public.renda_familiar seq_renda_familiar"
pg_restore: creating DEFAULT "public.sangria seq_sangria"
pg_restore: creating DEFAULT "public.sessao seq_sessao"
pg_restore: creating DEFAULT "public.sessao_evento_produto seq_sessao_evento_produto"
pg_restore: creating DEFAULT "public.setor seq_setor"
pg_restore: creating DEFAULT "public.taxa seq_taxa"
pg_restore: creating DEFAULT "public.troco seq_troco"
pg_restore: creating DEFAULT "public.usuario seq_usuario"
pg_restore: creating DEFAULT "public.usuario_tipo seq_usuario_tipo"
pg_restore: creating DEFAULT "public.vinculo seq_vinculo"
pg_restore: processing data for table "public.acesso"
pg_restore: [archiver (db)] Error from TOC entry 6602; 0 47400346 TABLE DATA acesso postgres
pg_restore: [archiver (db)] COPY failed for table "acesso": ERROR:  duplicate key value violates unique constraint "acesso_pkey"
DETAIL:  Key (seq_acesso)=(5596) already exists.
CONTEXT:  COPY acesso, line 1
pg_restore: processing data for table "public.acesso_historico"
pg_restore: [archiver (db)] Error from TOC entry 6603; 0 47400350 TABLE DATA acesso_historico postgres
pg_restore: [archiver (db)] COPY failed for table "acesso_historico": ERROR:  duplicate key value violates unique constraint "acesso_historico_pkey"
DETAIL:  Key (seq_acesso_historico)=(2775) already exists.
CONTEXT:  COPY acesso_historico, line 1
pg_restore: processing data for table "public.assento"
pg_restore: processing data for table "public.baixa"
pg_restore: [archiver (db)] Error from TOC entry 6608; 0 47400368 TABLE DATA baixa postgres
pg_restore: [archiver (db)] COPY failed for table "baixa": ERROR:  duplicate key value violates unique constraint "baixa_pkey"
DETAIL:  Key (seq_baixa)=(1) already exists.
CONTEXT:  COPY baixa, line 1
pg_restore: processing data for table "public.bilheteria"
pg_restore: [archiver (db)] Error from TOC entry 6610; 0 47400376 TABLE DATA bilheteria postgres
pg_restore: [archiver (db)] COPY failed for table "bilheteria": ERROR:  duplicate key value violates unique constraint "seq_bilheteria"
DETAIL:  Key (seq_bilheteria)=(1) already exists.
CONTEXT:  COPY bilheteria, line 1
pg_restore: processing data for table "public.boleto_macro"
pg_restore: [archiver (db)] Error from TOC entry 6612; 0 47400385 TABLE DATA boleto_macro postgres
pg_restore: [archiver (db)] COPY failed for table "boleto_macro": ERROR:  duplicate key value violates unique constraint "boleto_macro_pkey"
DETAIL:  Key (seq_boleto_macro)=(1) already exists.
CONTEXT:  COPY boleto_macro, line 1
pg_restore: processing data for table "public.cadeira"
pg_restore: [archiver (db)] Error from TOC entry 6614; 0 47400390 TABLE DATA cadeira postgres
pg_restore: [archiver (db)] COPY failed for table "cadeira": ERROR:  duplicate key value violates unique constraint "seq_cadeira"
DETAIL:  Key (seq_cadeira)=(1) already exists.
CONTEXT:  COPY cadeira, line 1
pg_restore: processing data for table "public.camarote"
pg_restore: [archiver (db)] Error from TOC entry 6616; 0 47400399 TABLE DATA camarote postgres
pg_restore: [archiver (db)] COPY failed for table "camarote": ERROR:  duplicate key value violates unique constraint "seq_camarote"
DETAIL:  Key (seq_camarote)=(3) already exists.
CONTEXT:  COPY camarote, line 2
pg_restore: processing data for table "public.cartao"
pg_restore: processing data for table "public.catraca"
pg_restore: [archiver (db)] Error from TOC entry 6620; 0 47400412 TABLE DATA catraca postgres
pg_restore: [archiver (db)] COPY failed for table "catraca": ERROR:  duplicate key value violates unique constraint "seq_catraca"
DETAIL:  Key (seq_catraca)=(3) already exists.
CONTEXT:  COPY catraca, line 1
pg_restore: processing data for table "public.ci_sessions"
pg_restore: [archiver (db)] Error from TOC entry 6622; 0 47400418 TABLE DATA ci_sessions postgres
pg_restore: [archiver (db)] COPY failed for table "ci_sessions": ERROR:  duplicate key value violates unique constraint "ci_sessions_pkey"
DETAIL:  Key (session_id)=(3a6077b85042964b4b2ef9e1746467a7) already exists.
CONTEXT:  COPY ci_sessions, line 1
pg_restore: processing data for table "public.clube"
pg_restore: [archiver (db)] Error from TOC entry 6623; 0 47400427 TABLE DATA clube postgres
pg_restore: [archiver (db)] COPY failed for table "clube": ERROR:  duplicate key value violates unique constraint "seq_clube"
DETAIL:  Key (seq_clube)=(1) already exists.
CONTEXT:  COPY clube, line 1
pg_restore: processing data for table "public.cobranca"
pg_restore: processing data for table "public.cobranca_retorno"
pg_restore: [archiver (db)] Error from TOC entry 6626; 0 47400441 TABLE DATA cobranca_retorno postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  column "seq_baixa" of relation "cobranca_retorno" does not exist
    Command was: COPY public.cobranca_retorno (seq_cobranca_retorno, titulo, nosso_numero, data_retorno, usuario_alteracao, data_alteracao, dt_retorno, cod_ocorrencia, dt_ocorrecia, dt_vencimento, vlr_vencimento, tp_documento, vlr_desp_cob, vlr_desp_out, vlr_pago, vlr_juros, vlr_out, vlr_desconto, dt_credito, nro_doc_empresa, identificador, dt_lido_sistema, seq_baixa) FROM stdin;

pg_restore: processing data for table "public.cobranca_titulo"
pg_restore: [archiver (db)] Error from TOC entry 6629; 0 47400450 TABLE DATA cobranca_titulo postgres
pg_restore: [archiver (db)] COPY failed for table "cobranca_titulo": ERROR:  duplicate key value violates unique constraint "seq_cobranca_titulo"
DETAIL:  Key (seq_cobranca_titulo)=(67) already exists.
CONTEXT:  COPY cobranca_titulo, line 64
pg_restore: processing data for table "public.cobranca_titulo_item"
pg_restore: [archiver (db)] Error from TOC entry 6630; 0 47400457 TABLE DATA cobranca_titulo_item postgres
pg_restore: [archiver (db)] COPY failed for table "cobranca_titulo_item": ERROR:  insert or update on table "cobranca_titulo_item" violates foreign key constraint "cobranca_titulo_item_seq_movimento_cobranca_fkey"
DETAIL:  Key (seq_movimento_cobranca)=(54200) is not present in table "movimento_cobranca".
pg_restore: processing data for table "public.competencia"
pg_restore: [archiver (db)] Error from TOC entry 6633; 0 47400465 TABLE DATA competencia postgres
pg_restore: [archiver (db)] COPY failed for table "competencia": ERROR:  duplicate key value violates unique constraint "competencia_pkey"
DETAIL:  Key (competencia)=(0390) already exists.
CONTEXT:  COPY competencia, line 1
pg_restore: processing data for table "public.competicao"
pg_restore: [archiver (db)] Error from TOC entry 6634; 0 47400472 TABLE DATA competicao postgres
pg_restore: [archiver (db)] COPY failed for table "competicao": ERROR:  duplicate key value violates unique constraint "seq_competicao"
DETAIL:  Key (seq_competicao)=(1) already exists.
CONTEXT:  COPY competicao, line 1
pg_restore: processing data for table "public.competicao_edicao"
pg_restore: [archiver (db)] Error from TOC entry 6635; 0 47400480 TABLE DATA competicao_edicao postgres
pg_restore: [archiver (db)] COPY failed for table "competicao_edicao": ERROR:  duplicate key value violates unique constraint "seq_competicao_edicao"
DETAIL:  Key (seq_competicao_edicao)=(2) already exists.
CONTEXT:  COPY competicao_edicao, line 1
pg_restore: processing data for table "public.conta"
pg_restore: [archiver (db)] Error from TOC entry 6638; 0 47400492 TABLE DATA conta postgres
pg_restore: [archiver (db)] COPY failed for table "conta": ERROR:  duplicate key value violates unique constraint "conta_pkey"
DETAIL:  Key (seq_conta)=(4) already exists.
CONTEXT:  COPY conta, line 1
pg_restore: processing data for table "public.dbf_cartoes_ecnh"
pg_restore: processing data for table "public.dbf_pessoas_ecnh"
pg_restore: processing data for table "public.dne"
pg_restore: [archiver (db)] Error from TOC entry 6641; 0 47400512 TABLE DATA dne postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  column "posicao_exercito" of relation "dne" does not exist
    Command was: COPY public.dne (cep, localidade, uf, bairro_inicial, bairro_final, logradouro, posicao_exercito, seq_dne) FROM stdin;

pg_restore: processing data for table "public.escolaridade"
pg_restore: [archiver (db)] Error from TOC entry 6643; 0 47400517 TABLE DATA escolaridade postgres
pg_restore: [archiver (db)] COPY failed for table "escolaridade": ERROR:  duplicate key value violates unique constraint "escolaridade_pkey"
DETAIL:  Key (seq_escolaridade)=(1) already exists.
CONTEXT:  COPY escolaridade, line 1
pg_restore: processing data for table "public.estado"
pg_restore: [archiver (db)] Error from TOC entry 6645; 0 47400522 TABLE DATA estado postgres
pg_restore: [archiver (db)] COPY failed for table "estado": ERROR:  duplicate key value violates unique constraint "estado_pkey"
DETAIL:  Key (seq_estado)=(1) already exists.
CONTEXT:  COPY estado, line 1
pg_restore: processing data for table "public.evento"
pg_restore: [archiver (db)] Error from TOC entry 6647; 0 47400527 TABLE DATA evento postgres
pg_restore: [archiver (db)] COPY failed for table "evento": ERROR:  relation "evento" does not exist
LINE 1: SELECT (select max(coalesce(even_ref,0)) + 1 from evento)
                                                          ^
QUERY:  SELECT (select max(coalesce(even_ref,0)) + 1 from evento)
CONTEXT:  PL/pgSQL function public.fnc_carrega_even_ref() line 3 at assignment
pg_restore: processing data for table "public.evento_local"
pg_restore: [archiver (db)] Error from TOC entry 6648; 0 47400532 TABLE DATA evento_local postgres
pg_restore: [archiver (db)] COPY failed for table "evento_local": ERROR:  duplicate key value violates unique constraint "seq_evento_local"
DETAIL:  Key (seq_evento_local)=(1) already exists.
CONTEXT:  COPY evento_local, line 1
pg_restore: processing data for table "public.evento_objetivo"
pg_restore: processing data for table "public.evento_produto"
pg_restore: processing data for table "public.faixa_salarial"
pg_restore: [archiver (db)] Error from TOC entry 6655; 0 47400561 TABLE DATA faixa_salarial postgres
pg_restore: [archiver (db)] COPY failed for table "faixa_salarial": ERROR:  duplicate key value violates unique constraint "faixa_salarial_pkey"
DETAIL:  Key (seq_faixa_salarial)=(1) already exists.
CONTEXT:  COPY faixa_salarial, line 1
pg_restore: processing data for table "public.forma_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6657; 0 47400569 TABLE DATA forma_pagamento postgres
pg_restore: [archiver (db)] COPY failed for table "forma_pagamento": ERROR:  duplicate key value violates unique constraint "seq_forma_pagamento"
DETAIL:  Key (seq_forma_pagamento)=(1) already exists.
CONTEXT:  COPY forma_pagamento, line 1
pg_restore: processing data for table "public.ingresso"
pg_restore: processing data for table "public.ingresso_numero"
pg_restore: [archiver (db)] Error from TOC entry 6660; 0 47400584 TABLE DATA ingresso_numero postgres
pg_restore: [archiver (db)] COPY failed for table "ingresso_numero": ERROR:  duplicate key value violates unique constraint "ingresso_numero_pkey"
DETAIL:  Key (ingresso_numero)=(10000000024812) already exists.
CONTEXT:  COPY ingresso_numero, line 1
pg_restore: processing data for table "public.instituicao_financeira"
pg_restore: [archiver (db)] Error from TOC entry 6662; 0 47400590 TABLE DATA instituicao_financeira postgres
pg_restore: [archiver (db)] COPY failed for table "instituicao_financeira": ERROR:  duplicate key value violates unique constraint "instituicao_financeira_seq_instituicao_financeira"
DETAIL:  Key (seq_instituicao_financeira)=(1) already exists.
CONTEXT:  COPY instituicao_financeira, line 1
pg_restore: processing data for table "public.liberacao"
pg_restore: processing data for table "public.liberacao_historico"
pg_restore: [archiver (db)] Error from TOC entry 6666; 0 47400603 TABLE DATA liberacao_historico postgres
pg_restore: [archiver (db)] COPY failed for table "liberacao_historico": ERROR:  duplicate key value violates unique constraint "seq_liberacao_historico_pkey"
DETAIL:  Key (seq_liberacao_historico)=(1) already exists.
CONTEXT:  COPY liberacao_historico, line 1
pg_restore: processing data for table "public.matricula"
pg_restore: [archiver (db)] Error from TOC entry 6667; 0 47400608 TABLE DATA matricula postgres
pg_restore: [archiver (db)] COPY failed for table "matricula": ERROR:  duplicate key value violates unique constraint "matricula_pkey"
DETAIL:  Key (matricula)=(1711) already exists.
CONTEXT:  COPY matricula, line 1
pg_restore: processing data for table "public.meio_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6671; 0 47400622 TABLE DATA meio_pagamento postgres
pg_restore: [archiver (db)] COPY failed for table "meio_pagamento": ERROR:  duplicate key value violates unique constraint "seq_meio_pagamento"
DETAIL:  Key (seq_meio_pagamento)=(1) already exists.
CONTEXT:  COPY meio_pagamento, line 1
pg_restore: processing data for table "public.menu"
pg_restore: [archiver (db)] Error from TOC entry 6673; 0 47400629 TABLE DATA menu postgres
pg_restore: [archiver (db)] COPY failed for table "menu": ERROR:  duplicate key value violates unique constraint "menu_pkey"
DETAIL:  Key (seq_menu)=(4) already exists.
CONTEXT:  COPY menu, line 1
pg_restore: processing data for table "public.movimento"
pg_restore: [archiver (db)] Error from TOC entry 6675; 0 47400635 TABLE DATA movimento postgres
pg_restore: [archiver (db)] COPY failed for table "movimento": ERROR:  duplicate key value violates unique constraint "seq_movimento"
DETAIL:  Key (seq_movimento)=(55896) already exists.
CONTEXT:  COPY movimento, line 4511
pg_restore: processing data for table "public.movimento_cobranca"
pg_restore: [archiver (db)] Error from TOC entry 6668; 0 47400614 TABLE DATA movimento_cobranca postgres
pg_restore: [archiver (db)] COPY failed for table "movimento_cobranca": ERROR:  insert or update on table "movimento_cobranca" violates foreign key constraint "matricula_matricula_cobranca_fk"
DETAIL:  Key (matricula)=(2281) is not present in table "matricula".
pg_restore: processing data for table "public.movimento_item"
pg_restore: [archiver (db)] Error from TOC entry 6676; 0 47400640 TABLE DATA movimento_item postgres
pg_restore: [archiver (db)] COPY failed for table "movimento_item": ERROR:  insert or update on table "movimento_item" violates foreign key constraint "movimento_item_seq_movimento_cobranca_fkey"
DETAIL:  Key (seq_movimento_cobranca)=(54200) is not present in table "movimento_cobranca".
pg_restore: processing data for table "public.movimento_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6678; 0 47400646 TABLE DATA movimento_pagamento postgres
pg_restore: [archiver (db)] COPY failed for table "movimento_pagamento": ERROR:  insert or update on table "movimento_pagamento" violates foreign key constraint "movimento_movimento_pagamento_fk"
DETAIL:  Key (seq_movimento)=(51513) is not present in table "movimento".
pg_restore: processing data for table "public.objeto"
pg_restore: [archiver (db)] Error from TOC entry 6681; 0 47400654 TABLE DATA objeto postgres
pg_restore: [archiver (db)] COPY failed for table "objeto": ERROR:  duplicate key value violates unique constraint "seq_objeto"
DETAIL:  Key (seq_objeto)=(4) already exists.
CONTEXT:  COPY objeto, line 1
pg_restore: processing data for table "public.obs_matricula"
pg_restore: processing data for table "public.pais"
pg_restore: [archiver (db)] Error from TOC entry 6686; 0 47400672 TABLE DATA pais postgres
pg_restore: [archiver (db)] COPY failed for table "pais": ERROR:  duplicate key value violates unique constraint "pais_pkey"
DETAIL:  Key (seq_pais)=(1) already exists.
CONTEXT:  COPY pais, line 1
pg_restore: processing data for table "public.perfil"
pg_restore: [archiver (db)] Error from TOC entry 6688; 0 47400677 TABLE DATA perfil postgres
pg_restore: [archiver (db)] COPY failed for table "perfil": ERROR:  duplicate key value violates unique constraint "seq_perfil"
DETAIL:  Key (seq_perfil)=(1) already exists.
CONTEXT:  COPY perfil, line 1
pg_restore: processing data for table "public.perfil_objeto"
pg_restore: [archiver (db)] Error from TOC entry 6689; 0 47400681 TABLE DATA perfil_objeto postgres
pg_restore: [archiver (db)] COPY failed for table "perfil_objeto": ERROR:  duplicate key value violates unique constraint "seq_perfil_objeto"
DETAIL:  Key (seq_perfil_objeto)=(1) already exists.
CONTEXT:  COPY perfil_objeto, line 1
pg_restore: processing data for table "public.pessoa"
pg_restore: [archiver (db)] Error from TOC entry 6692; 0 47400690 TABLE DATA pessoa postgres
pg_restore: [archiver (db)] COPY failed for table "pessoa": ERROR:  duplicate key value violates unique constraint "seq_pessoa"
DETAIL:  Key (seq_pessoa)=(2368) already exists.
CONTEXT:  COPY pessoa, line 1
pg_restore: processing data for table "public.pessoa_dados_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6693; 0 47400709 TABLE DATA pessoa_dados_pagamento postgres
pg_restore: [archiver (db)] COPY failed for table "pessoa_dados_pagamento": ERROR:  insert or update on table "pessoa_dados_pagamento" violates foreign key constraint "pessoa_pessoa_dados_pagamento_fk"
DETAIL:  Key (seq_pessoa)=(2663) is not present in table "pessoa".
pg_restore: processing data for table "public.pessoa_vinculo"
pg_restore: processing data for table "public.plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 6698; 0 47400723 TABLE DATA plano_pgto acbf
pg_restore: [archiver (db)] COPY failed for table "plano_pgto": ERROR:  insert or update on table "plano_pgto" violates foreign key constraint "plano_pgto_seq_produto_fkey"
DETAIL:  Key (seq_produto)=(331) is not present in table "produto".
pg_restore: processing data for table "public.portao"
pg_restore: [archiver (db)] Error from TOC entry 6700; 0 47400729 TABLE DATA portao postgres
pg_restore: [archiver (db)] COPY failed for table "portao": ERROR:  duplicate key value violates unique constraint "seq_portao"
DETAIL:  Key (seq_portao)=(3) already exists.
CONTEXT:  COPY portao, line 1
pg_restore: processing data for table "public.produto"
pg_restore: [archiver (db)] Error from TOC entry 6702; 0 47400735 TABLE DATA produto postgres
pg_restore: [archiver (db)] COPY failed for table "produto": ERROR:  duplicate key value violates unique constraint "seq_produto"
DETAIL:  Key (seq_produto)=(1) already exists.
CONTEXT:  COPY produto, line 1
pg_restore: processing data for table "public.produto_catraca"
pg_restore: processing data for table "public.produto_classe"
pg_restore: [archiver (db)] Error from TOC entry 6705; 0 47400748 TABLE DATA produto_classe postgres
pg_restore: [archiver (db)] COPY failed for table "produto_classe": ERROR:  duplicate key value violates unique constraint "produto_classe_pkey"
DETAIL:  Key (seq_produto_classe)=(1) already exists.
CONTEXT:  COPY produto_classe, line 1
pg_restore: processing data for table "public.produto_configuracao"
pg_restore: [archiver (db)] Error from TOC entry 6707; 0 47400754 TABLE DATA produto_configuracao postgres
pg_restore: [archiver (db)] COPY failed for table "produto_configuracao": ERROR:  duplicate key value violates unique constraint "pk_produto_configuracao"
DETAIL:  Key (seq_produto_configuracao)=(1) already exists.
CONTEXT:  COPY produto_configuracao, line 1
pg_restore: processing data for table "public.produto_contrato"
pg_restore: [archiver (db)] Error from TOC entry 6709; 0 47400761 TABLE DATA produto_contrato postgres
pg_restore: [archiver (db)] COPY failed for table "produto_contrato": ERROR:  duplicate key value violates unique constraint "seq_produto_contrato"
DETAIL:  Key (seq_produto_contrato)=(1) already exists.
CONTEXT:  COPY produto_contrato, line 1
pg_restore: processing data for table "public.produto_escolinha_turma"
pg_restore: [archiver (db)] Error from TOC entry 6753; 0 49893175 TABLE DATA produto_escolinha_turma postgres
pg_restore: [archiver (db)] COPY failed for table "produto_escolinha_turma": ERROR:  insert or update on table "produto_escolinha_turma" violates foreign key constraint "produto_produto_taxa_fk"
DETAIL:  Key (seq_produto)=(331) is not present in table "produto".
pg_restore: processing data for table "public.produto_plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 6711; 0 47400770 TABLE DATA produto_plano_pgto acbf
pg_restore: [archiver (db)] COPY failed for table "produto_plano_pgto": ERROR:  insert or update on table "produto_plano_pgto" violates foreign key constraint "produto_plano_pgto_seq_plano_pgto_fkey"
DETAIL:  Key (seq_plano_pgto)=(24) is not present in table "plano_pgto".
pg_restore: processing data for table "public.produto_taxa"
pg_restore: [archiver (db)] Error from TOC entry 6714; 0 47400778 TABLE DATA produto_taxa postgres
pg_restore: [archiver (db)] COPY failed for table "produto_taxa": ERROR:  duplicate key value violates unique constraint "seq_produto_taxa"
DETAIL:  Key (seq_produto_taxa)=(26) already exists.
CONTEXT:  COPY produto_taxa, line 1
pg_restore: processing data for table "public.profissao"
pg_restore: [archiver (db)] Error from TOC entry 6716; 0 47400788 TABLE DATA profissao postgres
pg_restore: [archiver (db)] COPY failed for table "profissao": ERROR:  duplicate key value violates unique constraint "seq_profissao"
DETAIL:  Key (seq_profissao)=(2) already exists.
CONTEXT:  COPY profissao, line 1
pg_restore: processing data for table "public.remessa"
pg_restore: [archiver (db)] Error from TOC entry 6718; 0 47400794 TABLE DATA remessa postgres
pg_restore: [archiver (db)] COPY failed for table "remessa": ERROR:  duplicate key value violates unique constraint "remessa_pkey"
DETAIL:  Key (seq_remessa)=(-1) already exists.
CONTEXT:  COPY remessa, line 1
pg_restore: processing data for table "public.remessa_item"
pg_restore: processing data for table "public.renda_familiar"
pg_restore: [archiver (db)] Error from TOC entry 6722; 0 47400804 TABLE DATA renda_familiar postgres
pg_restore: [archiver (db)] COPY failed for table "renda_familiar": ERROR:  duplicate key value violates unique constraint "renda_familiar_pkey"
DETAIL:  Key (seq_renda_familiar)=(1) already exists.
CONTEXT:  COPY renda_familiar, line 1
pg_restore: processing data for table "public.sangria"
pg_restore: processing data for table "public.sessao"
pg_restore: processing data for table "public.sessao_evento_produto"
pg_restore: processing data for table "public.setor"
pg_restore: [archiver (db)] Error from TOC entry 6736; 0 47400841 TABLE DATA setor postgres
pg_restore: [archiver (db)] COPY failed for table "setor": ERROR:  duplicate key value violates unique constraint "seq_setor"
DETAIL:  Key (seq_setor)=(1) already exists.
CONTEXT:  COPY setor, line 1
pg_restore: processing data for table "public.socio_tmp"
pg_restore: processing data for table "public.taxa"
pg_restore: [archiver (db)] Error from TOC entry 6739; 0 47400853 TABLE DATA taxa postgres
pg_restore: [archiver (db)] COPY failed for table "taxa": ERROR:  duplicate key value violates unique constraint "seq_taxa"
DETAIL:  Key (seq_taxa)=(5) already exists.
CONTEXT:  COPY taxa, line 4
pg_restore: processing data for table "public.tmp_importacao_socio"
pg_restore: processing data for table "public.tmp_socio"
pg_restore: processing data for table "public.troco"
pg_restore: processing data for table "public.usuario"
pg_restore: [archiver (db)] Error from TOC entry 6745; 0 47400872 TABLE DATA usuario postgres
pg_restore: [archiver (db)] COPY failed for table "usuario": ERROR:  duplicate key value violates unique constraint "seq_usuario"
DETAIL:  Key (seq_usuario)=(6) already exists.
CONTEXT:  COPY usuario, line 1
pg_restore: processing data for table "public.usuario_tipo"
pg_restore: [archiver (db)] Error from TOC entry 6747; 0 47400881 TABLE DATA usuario_tipo postgres
pg_restore: [archiver (db)] COPY failed for table "usuario_tipo": ERROR:  duplicate key value violates unique constraint "seq_usuario_tipo"
DETAIL:  Key (seq_usuario_tipo)=(1) already exists.
CONTEXT:  COPY usuario_tipo, line 1
pg_restore: processing data for table "public.vinculo"
pg_restore: [archiver (db)] Error from TOC entry 6749; 0 47400888 TABLE DATA vinculo postgres
pg_restore: [archiver (db)] COPY failed for table "vinculo": ERROR:  duplicate key value violates unique constraint "pk_vinculo"
DETAIL:  Key (seq_vinculo)=(1) already exists.
CONTEXT:  COPY vinculo, line 1
pg_restore: processing data for table "public.voucher"
pg_restore: executing SEQUENCE SET acesso_historico_seq_acesso_historico_seq
pg_restore: executing SEQUENCE SET acesso_seq_acesso_seq
pg_restore: executing SEQUENCE SET assento_seq_assento_seq
pg_restore: executing SEQUENCE SET baixa_seq_baixa_seq
pg_restore: executing SEQUENCE SET bilheteria_seq_bilheteria_seq
pg_restore: executing SEQUENCE SET boleto_macro_seq_boleto_macro_seq
pg_restore: executing SEQUENCE SET cadeira_seq_cadeira_seq_1
pg_restore: executing SEQUENCE SET camarote_seq_camarote_seq_1
pg_restore: executing SEQUENCE SET catraca_seq_catraca_seq
pg_restore: executing SEQUENCE SET clube_seq_clube_seq
pg_restore: executing SEQUENCE SET cobranca_retorno_seq_cobranca_retorno_seq_1
pg_restore: executing SEQUENCE SET cobranca_seq_cobranca_seq
pg_restore: executing SEQUENCE SET cobranca_titulo_item_seq_cobranca_titulo_item_seq_1
pg_restore: executing SEQUENCE SET cobranca_titulo_seq_cobranca_titulo_seq
pg_restore: executing SEQUENCE SET competicao_edicao_seq_competicao_edicao_seq
pg_restore: executing SEQUENCE SET competicao_seq_competicao_seq
pg_restore: executing SEQUENCE SET dne_seq_dne_seq
pg_restore: executing SEQUENCE SET escolaridade_seq_escolaridade_seq
pg_restore: executing SEQUENCE SET estado_seq_estado_seq
pg_restore: executing SEQUENCE SET evento_local_seq_evento_local_seq
pg_restore: executing SEQUENCE SET evento_objetivo_seq_evento_objetivo_seq
pg_restore: executing SEQUENCE SET evento_produto_seq_evento_produto_seq
pg_restore: executing SEQUENCE SET evento_seq_evento_seq
pg_restore: executing SEQUENCE SET faixa_salarial_seq_faixa_salarial_seq
pg_restore: executing SEQUENCE SET forma_pagamento_seq_forma_pagamento_seq
pg_restore: executing SEQUENCE SET ingresso_seq_ingresso_seq
pg_restore: executing SEQUENCE SET matricula_cobranca_seq_matricula_cobranca_seq
pg_restore: executing SEQUENCE SET matricula_matricula_seq
pg_restore: executing SEQUENCE SET meio_pagamento_seq_meio_pagamento_seq
pg_restore: executing SEQUENCE SET menu_seq_menu_seq
pg_restore: executing SEQUENCE SET movimento_item_seq_movimento_item_seq
pg_restore: executing SEQUENCE SET movimento_pagamento_seq_movimento_pagamento_seq
pg_restore: executing SEQUENCE SET movimento_seq_movimento_seq
pg_restore: executing SEQUENCE SET objeto_seq_objeto_seq
pg_restore: executing SEQUENCE SET obs_matricula_matricula_seq
pg_restore: executing SEQUENCE SET obs_matricula_seq_obs_matricula_seq
pg_restore: executing SEQUENCE SET pais_seq_pais_seq
pg_restore: executing SEQUENCE SET perfil_objeto_seq_perfil_objeto_seq
pg_restore: executing SEQUENCE SET perfil_seq_perfil_seq
pg_restore: executing SEQUENCE SET pessoa_dados_pagamento_seq_pessoa_dados_pagamento_seq
pg_restore: executing SEQUENCE SET pessoa_seq_pessoa_seq
pg_restore: executing SEQUENCE SET pessoa_vinculo_seq_pessoa_vinculo_seq
pg_restore: executing SEQUENCE SET plano_pgto_seq_plano_pgto_seq
pg_restore: executing SEQUENCE SET portao_seq_portao_seq_1
pg_restore: executing SEQUENCE SET produto_catraca_seq_produto_catraca_seq
pg_restore: executing SEQUENCE SET produto_classe_seq_produto_classe_seq
pg_restore: executing SEQUENCE SET produto_configuracao_seq_produto_configuracao_seq
pg_restore: executing SEQUENCE SET produto_contrato_seq_produto_contrato_seq_1
pg_restore: executing SEQUENCE SET produto_escolinha_turma_seq_produto_escolinha_turma_seq
pg_restore: executing SEQUENCE SET produto_plano_pgto_seq_produto_plano_pgto_seq
pg_restore: executing SEQUENCE SET produto_seq_produto_seq
pg_restore: executing SEQUENCE SET produto_taxa_seq_produto_taxa_seq
pg_restore: executing SEQUENCE SET profissao_seq_profissao_seq_1
pg_restore: executing SEQUENCE SET remessa_item_seq_remessa_item_seq
pg_restore: executing SEQUENCE SET remessa_seq_remessa_seq
pg_restore: executing SEQUENCE SET renda_familiar_seq_renda_familiar_seq
pg_restore: executing SEQUENCE SET sangria_seq_sangria_seq
pg_restore: executing SEQUENCE SET seq_cartao2
pg_restore: executing SEQUENCE SET seq_competencia
pg_restore: executing SEQUENCE SET seq_conta
pg_restore: executing SEQUENCE SET seq_ingresso_numero
pg_restore: executing SEQUENCE SET seq_instituicao_financeira
pg_restore: executing SEQUENCE SET seq_liberacao_historico
pg_restore: executing SEQUENCE SET seq_nosso_numero
pg_restore: executing SEQUENCE SET seq_seq_liberacao
pg_restore: executing SEQUENCE SET seq_voucher
pg_restore: executing SEQUENCE SET sessao_evento_produto_seq_sessao_evento_produto_seq
pg_restore: executing SEQUENCE SET sessao_seq_sessao_seq
pg_restore: executing SEQUENCE SET setor_seq_setor_seq_1
pg_restore: executing SEQUENCE SET taxa_seq_taxa_seq
pg_restore: executing SEQUENCE SET troco_seq_troco_seq
pg_restore: executing SEQUENCE SET usuario_seq_usuario_seq
pg_restore: executing SEQUENCE SET usuario_tipo_seq_usuario_tipo_seq
pg_restore: executing SEQUENCE SET vinculo_seq_vinculo_seq
pg_restore: creating CONSTRAINT "public.acesso_historico acesso_historico_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6262; 2606 49604315 CONSTRAINT acesso_historico acesso_historico_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "acesso_historico" are not allowed
    Command was: ALTER TABLE ONLY public.acesso_historico
    ADD CONSTRAINT acesso_historico_pkey PRIMARY KEY (seq_acesso_historico);



pg_restore: creating CONSTRAINT "public.acesso acesso_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6260; 2606 49604317 CONSTRAINT acesso acesso_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "acesso" are not allowed
    Command was: ALTER TABLE ONLY public.acesso
    ADD CONSTRAINT acesso_pkey PRIMARY KEY (seq_acesso);



pg_restore: creating CONSTRAINT "public.baixa baixa_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6266; 2606 49604319 CONSTRAINT baixa baixa_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "baixa" are not allowed
    Command was: ALTER TABLE ONLY public.baixa
    ADD CONSTRAINT baixa_pkey PRIMARY KEY (seq_baixa);



pg_restore: creating CONSTRAINT "public.boleto_macro boleto_macro_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6270; 2606 49604321 CONSTRAINT boleto_macro boleto_macro_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "boleto_macro" are not allowed
    Command was: ALTER TABLE ONLY public.boleto_macro
    ADD CONSTRAINT boleto_macro_pkey PRIMARY KEY (seq_boleto_macro);



pg_restore: creating CONSTRAINT "public.ci_sessions ci_sessions_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6280; 2606 49604323 CONSTRAINT ci_sessions ci_sessions_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "ci_sessions" are not allowed
    Command was: ALTER TABLE ONLY public.ci_sessions
    ADD CONSTRAINT ci_sessions_pkey PRIMARY KEY (session_id);



pg_restore: creating CONSTRAINT "public.competencia competencia_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6292; 2606 49604325 CONSTRAINT competencia competencia_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "competencia" are not allowed
    Command was: ALTER TABLE ONLY public.competencia
    ADD CONSTRAINT competencia_pkey PRIMARY KEY (competencia);



pg_restore: creating CONSTRAINT "public.conta conta_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6298; 2606 49604327 CONSTRAINT conta conta_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "conta" are not allowed
    Command was: ALTER TABLE ONLY public.conta
    ADD CONSTRAINT conta_pkey PRIMARY KEY (seq_conta);



pg_restore: creating CONSTRAINT "public.dne dne_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6302; 2606 49604329 CONSTRAINT dne dne_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "dne" are not allowed
    Command was: ALTER TABLE ONLY public.dne
    ADD CONSTRAINT dne_pkey PRIMARY KEY (seq_dne);



pg_restore: creating CONSTRAINT "public.escolaridade escolaridade_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6304; 2606 49604331 CONSTRAINT escolaridade escolaridade_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "escolaridade" are not allowed
    Command was: ALTER TABLE ONLY public.escolaridade
    ADD CONSTRAINT escolaridade_pkey PRIMARY KEY (seq_escolaridade);



pg_restore: creating CONSTRAINT "public.estado estado_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6306; 2606 49604333 CONSTRAINT estado estado_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "estado" are not allowed
    Command was: ALTER TABLE ONLY public.estado
    ADD CONSTRAINT estado_pkey PRIMARY KEY (seq_estado);



pg_restore: creating CONSTRAINT "public.evento_objetivo evento_objetivo_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6312; 2606 49604335 CONSTRAINT evento_objetivo evento_objetivo_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "evento_objetivo" are not allowed
    Command was: ALTER TABLE ONLY public.evento_objetivo
    ADD CONSTRAINT evento_objetivo_pkey PRIMARY KEY (seq_evento_objetivo);



pg_restore: creating CONSTRAINT "public.faixa_salarial faixa_salarial_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6316; 2606 49604337 CONSTRAINT faixa_salarial faixa_salarial_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "faixa_salarial" are not allowed
    Command was: ALTER TABLE ONLY public.faixa_salarial
    ADD CONSTRAINT faixa_salarial_pkey PRIMARY KEY (seq_faixa_salarial);



pg_restore: creating CONSTRAINT "public.ingresso_numero ingresso_numero_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6322; 2606 49604339 CONSTRAINT ingresso_numero ingresso_numero_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "ingresso_numero" are not allowed
    Command was: ALTER TABLE ONLY public.ingresso_numero
    ADD CONSTRAINT ingresso_numero_pkey PRIMARY KEY (ingresso_numero);



pg_restore: creating CONSTRAINT "public.instituicao_financeira instituicao_financeira_seq_instituicao_financeira"
pg_restore: [archiver (db)] Error from TOC entry 6324; 2606 49604341 CONSTRAINT instituicao_financeira instituicao_financeira_seq_instituicao_financeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "instituicao_financeira" are not allowed
    Command was: ALTER TABLE ONLY public.instituicao_financeira
    ADD CONSTRAINT instituicao_financeira_seq_instituicao_financeira PRIMARY KEY (seq_instituicao_financeira);



pg_restore: creating CONSTRAINT "public.liberacao liberacao_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6326; 2606 49604343 CONSTRAINT liberacao liberacao_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "liberacao" are not allowed
    Command was: ALTER TABLE ONLY public.liberacao
    ADD CONSTRAINT liberacao_pkey PRIMARY KEY (seq_liberacao);



pg_restore: creating CONSTRAINT "public.matricula matricula_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6330; 2606 49604345 CONSTRAINT matricula matricula_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "matricula" are not allowed
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT matricula_pkey PRIMARY KEY (matricula);



pg_restore: creating CONSTRAINT "public.menu menu_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6336; 2606 49604347 CONSTRAINT menu menu_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "menu" are not allowed
    Command was: ALTER TABLE ONLY public.menu
    ADD CONSTRAINT menu_pkey PRIMARY KEY (seq_menu);



pg_restore: creating CONSTRAINT "public.obs_matricula obs_matricula_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6348; 2606 49604349 CONSTRAINT obs_matricula obs_matricula_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "obs_matricula" are not allowed
    Command was: ALTER TABLE ONLY public.obs_matricula
    ADD CONSTRAINT obs_matricula_pkey PRIMARY KEY (matricula);



pg_restore: creating CONSTRAINT "public.pais pais_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6350; 2606 49604351 CONSTRAINT pais pais_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "pais" are not allowed
    Command was: ALTER TABLE ONLY public.pais
    ADD CONSTRAINT pais_pkey PRIMARY KEY (seq_pais);



pg_restore: creating CONSTRAINT "public.pessoa_dados_pagamento pessoa_dados_pagamento_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6358; 2606 49604353 CONSTRAINT pessoa_dados_pagamento pessoa_dados_pagamento_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "pessoa_dados_pagamento" are not allowed
    Command was: ALTER TABLE ONLY public.pessoa_dados_pagamento
    ADD CONSTRAINT pessoa_dados_pagamento_pkey PRIMARY KEY (seq_pessoa_dados_pagamento);



pg_restore: creating CONSTRAINT "public.produto_configuracao pk_produto_configuracao"
pg_restore: [archiver (db)] Error from TOC entry 6372; 2606 49604355 CONSTRAINT produto_configuracao pk_produto_configuracao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto_configuracao" are not allowed
    Command was: ALTER TABLE ONLY public.produto_configuracao
    ADD CONSTRAINT pk_produto_configuracao PRIMARY KEY (seq_produto_configuracao);



pg_restore: creating CONSTRAINT "public.vinculo pk_vinculo"
pg_restore: [archiver (db)] Error from TOC entry 6404; 2606 49604357 CONSTRAINT vinculo pk_vinculo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "vinculo" are not allowed
    Command was: ALTER TABLE ONLY public.vinculo
    ADD CONSTRAINT pk_vinculo PRIMARY KEY (seq_vinculo);



pg_restore: creating CONSTRAINT "public.plano_pgto plano_pgto_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6362; 2606 49604359 CONSTRAINT plano_pgto plano_pgto_pkey acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "plano_pgto" are not allowed
    Command was: ALTER TABLE ONLY public.plano_pgto
    ADD CONSTRAINT plano_pgto_pkey PRIMARY KEY (seq_plano_pgto);



pg_restore: creating CONSTRAINT "public.produto_classe produto_classe_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6370; 2606 49604361 CONSTRAINT produto_classe produto_classe_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto_classe" are not allowed
    Command was: ALTER TABLE ONLY public.produto_classe
    ADD CONSTRAINT produto_classe_pkey PRIMARY KEY (seq_produto_classe);



pg_restore: creating CONSTRAINT "public.produto_plano_pgto produto_plano_pgto_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6376; 2606 49604363 CONSTRAINT produto_plano_pgto produto_plano_pgto_pkey acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto_plano_pgto" are not allowed
    Command was: ALTER TABLE ONLY public.produto_plano_pgto
    ADD CONSTRAINT produto_plano_pgto_pkey PRIMARY KEY (seq_produto_plano_pgto);



pg_restore: creating CONSTRAINT "public.remessa_item remessa_item_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6384; 2606 49604365 CONSTRAINT remessa_item remessa_item_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "remessa_item" are not allowed
    Command was: ALTER TABLE ONLY public.remessa_item
    ADD CONSTRAINT remessa_item_pkey PRIMARY KEY (seq_remessa_item);



pg_restore: creating CONSTRAINT "public.remessa remessa_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6382; 2606 49604367 CONSTRAINT remessa remessa_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "remessa" are not allowed
    Command was: ALTER TABLE ONLY public.remessa
    ADD CONSTRAINT remessa_pkey PRIMARY KEY (seq_remessa);



pg_restore: creating CONSTRAINT "public.renda_familiar renda_familiar_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6386; 2606 49604369 CONSTRAINT renda_familiar renda_familiar_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "renda_familiar" are not allowed
    Command was: ALTER TABLE ONLY public.renda_familiar
    ADD CONSTRAINT renda_familiar_pkey PRIMARY KEY (seq_renda_familiar);



pg_restore: creating CONSTRAINT "public.assento seq_assento"
pg_restore: [archiver (db)] Error from TOC entry 6264; 2606 49604371 CONSTRAINT assento seq_assento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "assento" are not allowed
    Command was: ALTER TABLE ONLY public.assento
    ADD CONSTRAINT seq_assento PRIMARY KEY (seq_assento);



pg_restore: creating CONSTRAINT "public.bilheteria seq_bilheteria"
pg_restore: [archiver (db)] Error from TOC entry 6268; 2606 49604373 CONSTRAINT bilheteria seq_bilheteria postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "bilheteria" are not allowed
    Command was: ALTER TABLE ONLY public.bilheteria
    ADD CONSTRAINT seq_bilheteria PRIMARY KEY (seq_bilheteria);



pg_restore: creating CONSTRAINT "public.cadeira seq_cadeira"
pg_restore: [archiver (db)] Error from TOC entry 6272; 2606 49604375 CONSTRAINT cadeira seq_cadeira postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "cadeira" are not allowed
    Command was: ALTER TABLE ONLY public.cadeira
    ADD CONSTRAINT seq_cadeira PRIMARY KEY (seq_cadeira);



pg_restore: creating CONSTRAINT "public.camarote seq_camarote"
pg_restore: [archiver (db)] Error from TOC entry 6274; 2606 49604377 CONSTRAINT camarote seq_camarote postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "camarote" are not allowed
    Command was: ALTER TABLE ONLY public.camarote
    ADD CONSTRAINT seq_camarote PRIMARY KEY (seq_camarote);



pg_restore: creating CONSTRAINT "public.cartao seq_cartao"
pg_restore: [archiver (db)] Error from TOC entry 6276; 2606 49604379 CONSTRAINT cartao seq_cartao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "cartao" are not allowed
    Command was: ALTER TABLE ONLY public.cartao
    ADD CONSTRAINT seq_cartao PRIMARY KEY (seq_cartao);



pg_restore: creating CONSTRAINT "public.catraca seq_catraca"
pg_restore: [archiver (db)] Error from TOC entry 6278; 2606 49604381 CONSTRAINT catraca seq_catraca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "catraca" are not allowed
    Command was: ALTER TABLE ONLY public.catraca
    ADD CONSTRAINT seq_catraca PRIMARY KEY (seq_catraca);



pg_restore: creating CONSTRAINT "public.clube seq_clube"
pg_restore: [archiver (db)] Error from TOC entry 6282; 2606 49604383 CONSTRAINT clube seq_clube postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "clube" are not allowed
    Command was: ALTER TABLE ONLY public.clube
    ADD CONSTRAINT seq_clube PRIMARY KEY (seq_clube);



pg_restore: creating CONSTRAINT "public.cobranca seq_cobranca"
pg_restore: [archiver (db)] Error from TOC entry 6284; 2606 49604385 CONSTRAINT cobranca seq_cobranca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "cobranca" are not allowed
    Command was: ALTER TABLE ONLY public.cobranca
    ADD CONSTRAINT seq_cobranca PRIMARY KEY (seq_cobranca);



pg_restore: creating CONSTRAINT "public.cobranca_retorno seq_cobranca_retorno"
pg_restore: [archiver (db)] Error from TOC entry 6286; 2606 49604387 CONSTRAINT cobranca_retorno seq_cobranca_retorno postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "cobranca_retorno" are not allowed
    Command was: ALTER TABLE ONLY public.cobranca_retorno
    ADD CONSTRAINT seq_cobranca_retorno PRIMARY KEY (seq_cobranca_retorno);



pg_restore: creating CONSTRAINT "public.cobranca_titulo seq_cobranca_titulo"
pg_restore: [archiver (db)] Error from TOC entry 6288; 2606 49604389 CONSTRAINT cobranca_titulo seq_cobranca_titulo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "cobranca_titulo" are not allowed
    Command was: ALTER TABLE ONLY public.cobranca_titulo
    ADD CONSTRAINT seq_cobranca_titulo PRIMARY KEY (seq_cobranca_titulo);



pg_restore: creating CONSTRAINT "public.cobranca_titulo_item seq_cobranca_titulo_item"
pg_restore: [archiver (db)] Error from TOC entry 6290; 2606 49604391 CONSTRAINT cobranca_titulo_item seq_cobranca_titulo_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "cobranca_titulo_item" are not allowed
    Command was: ALTER TABLE ONLY public.cobranca_titulo_item
    ADD CONSTRAINT seq_cobranca_titulo_item PRIMARY KEY (seq_cobranca_titulo_item);



pg_restore: creating CONSTRAINT "public.competicao seq_competicao"
pg_restore: [archiver (db)] Error from TOC entry 6294; 2606 49604393 CONSTRAINT competicao seq_competicao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "competicao" are not allowed
    Command was: ALTER TABLE ONLY public.competicao
    ADD CONSTRAINT seq_competicao PRIMARY KEY (seq_competicao);



pg_restore: creating CONSTRAINT "public.competicao_edicao seq_competicao_edicao"
pg_restore: [archiver (db)] Error from TOC entry 6296; 2606 49604395 CONSTRAINT competicao_edicao seq_competicao_edicao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "competicao_edicao" are not allowed
    Command was: ALTER TABLE ONLY public.competicao_edicao
    ADD CONSTRAINT seq_competicao_edicao PRIMARY KEY (seq_competicao_edicao);



pg_restore: creating CONSTRAINT "public.evento seq_evento"
pg_restore: [archiver (db)] Error from TOC entry 6308; 2606 49604397 CONSTRAINT evento seq_evento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "evento" are not allowed
    Command was: ALTER TABLE ONLY public.evento
    ADD CONSTRAINT seq_evento PRIMARY KEY (seq_evento);



pg_restore: creating CONSTRAINT "public.evento_local seq_evento_local"
pg_restore: [archiver (db)] Error from TOC entry 6310; 2606 49604399 CONSTRAINT evento_local seq_evento_local postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "evento_local" are not allowed
    Command was: ALTER TABLE ONLY public.evento_local
    ADD CONSTRAINT seq_evento_local PRIMARY KEY (seq_evento_local);



pg_restore: creating CONSTRAINT "public.evento_produto seq_evento_produto"
pg_restore: [archiver (db)] Error from TOC entry 6314; 2606 49604401 CONSTRAINT evento_produto seq_evento_produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "evento_produto" are not allowed
    Command was: ALTER TABLE ONLY public.evento_produto
    ADD CONSTRAINT seq_evento_produto PRIMARY KEY (seq_evento_produto);



pg_restore: creating CONSTRAINT "public.forma_pagamento seq_forma_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6318; 2606 49604403 CONSTRAINT forma_pagamento seq_forma_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "forma_pagamento" are not allowed
    Command was: ALTER TABLE ONLY public.forma_pagamento
    ADD CONSTRAINT seq_forma_pagamento PRIMARY KEY (seq_forma_pagamento);



pg_restore: creating CONSTRAINT "public.ingresso seq_ingresso"
pg_restore: [archiver (db)] Error from TOC entry 6320; 2606 49604405 CONSTRAINT ingresso seq_ingresso postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "ingresso" are not allowed
    Command was: ALTER TABLE ONLY public.ingresso
    ADD CONSTRAINT seq_ingresso PRIMARY KEY (seq_ingresso);



pg_restore: creating CONSTRAINT "public.liberacao_historico seq_liberacao_historico_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6328; 2606 49604407 CONSTRAINT liberacao_historico seq_liberacao_historico_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "liberacao_historico" are not allowed
    Command was: ALTER TABLE ONLY public.liberacao_historico
    ADD CONSTRAINT seq_liberacao_historico_pkey PRIMARY KEY (seq_liberacao_historico);



pg_restore: creating CONSTRAINT "public.movimento_cobranca seq_matricula_cobranca"
pg_restore: [archiver (db)] Error from TOC entry 6332; 2606 49604409 CONSTRAINT movimento_cobranca seq_matricula_cobranca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "movimento_cobranca" are not allowed
    Command was: ALTER TABLE ONLY public.movimento_cobranca
    ADD CONSTRAINT seq_matricula_cobranca PRIMARY KEY (seq_movimento_cobranca);



pg_restore: creating CONSTRAINT "public.meio_pagamento seq_meio_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6334; 2606 49604411 CONSTRAINT meio_pagamento seq_meio_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "meio_pagamento" are not allowed
    Command was: ALTER TABLE ONLY public.meio_pagamento
    ADD CONSTRAINT seq_meio_pagamento PRIMARY KEY (seq_meio_pagamento);



pg_restore: creating CONSTRAINT "public.movimento seq_movimento"
pg_restore: [archiver (db)] Error from TOC entry 6340; 2606 49604413 CONSTRAINT movimento seq_movimento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "movimento" are not allowed
    Command was: ALTER TABLE ONLY public.movimento
    ADD CONSTRAINT seq_movimento PRIMARY KEY (seq_movimento);



pg_restore: creating CONSTRAINT "public.movimento_item seq_movimento_item"
pg_restore: [archiver (db)] Error from TOC entry 6342; 2606 49604415 CONSTRAINT movimento_item seq_movimento_item postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "movimento_item" are not allowed
    Command was: ALTER TABLE ONLY public.movimento_item
    ADD CONSTRAINT seq_movimento_item PRIMARY KEY (seq_movimento_item);



pg_restore: creating CONSTRAINT "public.movimento_pagamento seq_movimento_pagamento"
pg_restore: [archiver (db)] Error from TOC entry 6344; 2606 49604417 CONSTRAINT movimento_pagamento seq_movimento_pagamento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "movimento_pagamento" are not allowed
    Command was: ALTER TABLE ONLY public.movimento_pagamento
    ADD CONSTRAINT seq_movimento_pagamento PRIMARY KEY (seq_movimento_pagamento);



pg_restore: creating CONSTRAINT "public.objeto seq_objeto"
pg_restore: [archiver (db)] Error from TOC entry 6346; 2606 49604419 CONSTRAINT objeto seq_objeto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "objeto" are not allowed
    Command was: ALTER TABLE ONLY public.objeto
    ADD CONSTRAINT seq_objeto PRIMARY KEY (seq_objeto);



pg_restore: creating CONSTRAINT "public.perfil seq_perfil"
pg_restore: [archiver (db)] Error from TOC entry 6352; 2606 49604421 CONSTRAINT perfil seq_perfil postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "perfil" are not allowed
    Command was: ALTER TABLE ONLY public.perfil
    ADD CONSTRAINT seq_perfil PRIMARY KEY (seq_perfil);



pg_restore: creating CONSTRAINT "public.perfil_objeto seq_perfil_objeto"
pg_restore: [archiver (db)] Error from TOC entry 6354; 2606 49604423 CONSTRAINT perfil_objeto seq_perfil_objeto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "perfil_objeto" are not allowed
    Command was: ALTER TABLE ONLY public.perfil_objeto
    ADD CONSTRAINT seq_perfil_objeto PRIMARY KEY (seq_perfil_objeto);



pg_restore: creating CONSTRAINT "public.pessoa seq_pessoa"
pg_restore: [archiver (db)] Error from TOC entry 6356; 2606 49604425 CONSTRAINT pessoa seq_pessoa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "pessoa" are not allowed
    Command was: ALTER TABLE ONLY public.pessoa
    ADD CONSTRAINT seq_pessoa PRIMARY KEY (seq_pessoa);



pg_restore: creating CONSTRAINT "public.pessoa_vinculo seq_pessoa_vinculo"
pg_restore: [archiver (db)] Error from TOC entry 6360; 2606 49604427 CONSTRAINT pessoa_vinculo seq_pessoa_vinculo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "pessoa_vinculo" are not allowed
    Command was: ALTER TABLE ONLY public.pessoa_vinculo
    ADD CONSTRAINT seq_pessoa_vinculo PRIMARY KEY (seq_pessoa_vinculo);



pg_restore: creating CONSTRAINT "public.portao seq_portao"
pg_restore: [archiver (db)] Error from TOC entry 6364; 2606 49604429 CONSTRAINT portao seq_portao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "portao" are not allowed
    Command was: ALTER TABLE ONLY public.portao
    ADD CONSTRAINT seq_portao PRIMARY KEY (seq_portao);



pg_restore: creating CONSTRAINT "public.produto seq_produto"
pg_restore: [archiver (db)] Error from TOC entry 6366; 2606 49604431 CONSTRAINT produto seq_produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto" are not allowed
    Command was: ALTER TABLE ONLY public.produto
    ADD CONSTRAINT seq_produto PRIMARY KEY (seq_produto);



pg_restore: creating CONSTRAINT "public.produto_catraca seq_produto_catraca"
pg_restore: [archiver (db)] Error from TOC entry 6368; 2606 49604433 CONSTRAINT produto_catraca seq_produto_catraca postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto_catraca" are not allowed
    Command was: ALTER TABLE ONLY public.produto_catraca
    ADD CONSTRAINT seq_produto_catraca PRIMARY KEY (seq_produto_catraca);



pg_restore: creating CONSTRAINT "public.produto_contrato seq_produto_contrato"
pg_restore: [archiver (db)] Error from TOC entry 6374; 2606 49604435 CONSTRAINT produto_contrato seq_produto_contrato postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto_contrato" are not allowed
    Command was: ALTER TABLE ONLY public.produto_contrato
    ADD CONSTRAINT seq_produto_contrato PRIMARY KEY (seq_produto_contrato);



pg_restore: creating CONSTRAINT "public.produto_taxa seq_produto_taxa"
pg_restore: [archiver (db)] Error from TOC entry 6378; 2606 49604437 CONSTRAINT produto_taxa seq_produto_taxa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "produto_taxa" are not allowed
    Command was: ALTER TABLE ONLY public.produto_taxa
    ADD CONSTRAINT seq_produto_taxa PRIMARY KEY (seq_produto_taxa);



pg_restore: creating CONSTRAINT "public.profissao seq_profissao"
pg_restore: [archiver (db)] Error from TOC entry 6380; 2606 49604439 CONSTRAINT profissao seq_profissao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "profissao" are not allowed
    Command was: ALTER TABLE ONLY public.profissao
    ADD CONSTRAINT seq_profissao PRIMARY KEY (seq_profissao);



pg_restore: creating CONSTRAINT "public.sangria seq_sangria"
pg_restore: [archiver (db)] Error from TOC entry 6388; 2606 49604441 CONSTRAINT sangria seq_sangria postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "sangria" are not allowed
    Command was: ALTER TABLE ONLY public.sangria
    ADD CONSTRAINT seq_sangria PRIMARY KEY (seq_sangria);



pg_restore: creating CONSTRAINT "public.sessao seq_sessao"
pg_restore: [archiver (db)] Error from TOC entry 6390; 2606 49604443 CONSTRAINT sessao seq_sessao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "sessao" are not allowed
    Command was: ALTER TABLE ONLY public.sessao
    ADD CONSTRAINT seq_sessao PRIMARY KEY (seq_sessao);



pg_restore: creating CONSTRAINT "public.sessao_evento_produto seq_sessao_evento_produto"
pg_restore: [archiver (db)] Error from TOC entry 6392; 2606 49604445 CONSTRAINT sessao_evento_produto seq_sessao_evento_produto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "sessao_evento_produto" are not allowed
    Command was: ALTER TABLE ONLY public.sessao_evento_produto
    ADD CONSTRAINT seq_sessao_evento_produto PRIMARY KEY (seq_sessao_evento_produto);



pg_restore: creating CONSTRAINT "public.setor seq_setor"
pg_restore: [archiver (db)] Error from TOC entry 6394; 2606 49604447 CONSTRAINT setor seq_setor postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "setor" are not allowed
    Command was: ALTER TABLE ONLY public.setor
    ADD CONSTRAINT seq_setor PRIMARY KEY (seq_setor);



pg_restore: creating CONSTRAINT "public.taxa seq_taxa"
pg_restore: [archiver (db)] Error from TOC entry 6396; 2606 49604449 CONSTRAINT taxa seq_taxa postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "taxa" are not allowed
    Command was: ALTER TABLE ONLY public.taxa
    ADD CONSTRAINT seq_taxa PRIMARY KEY (seq_taxa);



pg_restore: creating CONSTRAINT "public.troco seq_troco"
pg_restore: [archiver (db)] Error from TOC entry 6398; 2606 49604451 CONSTRAINT troco seq_troco postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "troco" are not allowed
    Command was: ALTER TABLE ONLY public.troco
    ADD CONSTRAINT seq_troco PRIMARY KEY (seq_troco);



pg_restore: creating CONSTRAINT "public.usuario seq_usuario"
pg_restore: [archiver (db)] Error from TOC entry 6400; 2606 49604453 CONSTRAINT usuario seq_usuario postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "usuario" are not allowed
    Command was: ALTER TABLE ONLY public.usuario
    ADD CONSTRAINT seq_usuario PRIMARY KEY (seq_usuario);



pg_restore: creating CONSTRAINT "public.usuario_tipo seq_usuario_tipo"
pg_restore: [archiver (db)] Error from TOC entry 6402; 2606 49604455 CONSTRAINT usuario_tipo seq_usuario_tipo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "usuario_tipo" are not allowed
    Command was: ALTER TABLE ONLY public.usuario_tipo
    ADD CONSTRAINT seq_usuario_tipo PRIMARY KEY (seq_usuario_tipo);



pg_restore: creating CONSTRAINT "public.voucher voucher_pkey"
pg_restore: [archiver (db)] Error from TOC entry 6406; 2606 49604457 CONSTRAINT voucher voucher_pkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  multiple primary keys for table "voucher" are not allowed
    Command was: ALTER TABLE ONLY public.voucher
    ADD CONSTRAINT voucher_pkey PRIMARY KEY (seq_voucher);



pg_restore: creating INDEX "public.dne_cep_idx"
pg_restore: [archiver (db)] Error from TOC entry 6299; 1259 49606689 INDEX dne_cep_idx postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dne_cep_idx" already exists
    Command was: CREATE INDEX dne_cep_idx ON public.dne USING btree (cep);



pg_restore: creating INDEX "public.dne_localidade_uf_idx"
pg_restore: [archiver (db)] Error from TOC entry 6300; 1259 49606690 INDEX dne_localidade_uf_idx postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "dne_localidade_uf_idx" already exists
    Command was: CREATE INDEX dne_localidade_uf_idx ON public.dne USING btree (localidade, uf);



pg_restore: creating INDEX "public.fki_"
pg_restore: [archiver (db)] Error from TOC entry 6337; 1259 49606691 INDEX fki_ postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "fki_" already exists
    Command was: CREATE INDEX fki_ ON public.movimento USING btree (seq_pessoa);



pg_restore: creating INDEX "public.fki_usuario_movimento"
pg_restore: [archiver (db)] Error from TOC entry 6338; 1259 49606692 INDEX fki_usuario_movimento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  relation "fki_usuario_movimento" already exists
    Command was: CREATE INDEX fki_usuario_movimento ON public.movimento USING btree (operador);



pg_restore: creating TRIGGER "public.evento trg_carrega_even_ref"
pg_restore: [archiver (db)] Error from TOC entry 6481; 2620 49606693 TRIGGER evento trg_carrega_even_ref postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  trigger "trg_carrega_even_ref" for relation "evento" already exists
    Command was: CREATE TRIGGER trg_carrega_even_ref AFTER INSERT ON public.evento FOR EACH ROW EXECUTE PROCEDURE public.fnc_carrega_even_ref();



pg_restore: creating TRIGGER "public.cobranca_titulo trg_cobranca_titulo_bu"
pg_restore: [archiver (db)] Error from TOC entry 6480; 2620 49606694 TRIGGER cobranca_titulo trg_cobranca_titulo_bu postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  trigger "trg_cobranca_titulo_bu" for relation "cobranca_titulo" already exists
    Command was: CREATE TRIGGER trg_cobranca_titulo_bu BEFORE UPDATE ON public.cobranca_titulo FOR EACH ROW EXECUTE PROCEDURE public.fnc_cobranca_titulo();



pg_restore: creating TRIGGER "public.sessao trg_depois_inserir_sessao"
pg_restore: [archiver (db)] Error from TOC entry 6484; 2620 49606695 TRIGGER sessao trg_depois_inserir_sessao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  trigger "trg_depois_inserir_sessao" for relation "sessao" already exists
    Command was: CREATE TRIGGER trg_depois_inserir_sessao AFTER INSERT OR UPDATE ON public.sessao FOR EACH ROW EXECUTE PROCEDURE public.depois_inserir_sessao();



pg_restore: creating TRIGGER "public.movimento trg_estorna_movimento"
pg_restore: [archiver (db)] Error from TOC entry 6482; 2620 49606696 TRIGGER movimento trg_estorna_movimento postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  trigger "trg_estorna_movimento" for relation "movimento" already exists
    Command was: CREATE TRIGGER trg_estorna_movimento AFTER INSERT OR UPDATE ON public.movimento FOR EACH ROW EXECUTE PROCEDURE public.estorna_movimento();



pg_restore: creating TRIGGER "public.movimento_item trg_gera_ingressos"
pg_restore: [archiver (db)] Error from TOC entry 6483; 2620 49606697 TRIGGER movimento_item trg_gera_ingressos postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  trigger "trg_gera_ingressos" for relation "movimento_item" already exists
    Command was: CREATE TRIGGER trg_gera_ingressos AFTER INSERT OR UPDATE ON public.movimento_item FOR EACH ROW EXECUTE PROCEDURE public.gera_ingressos_do_pagamento();

ALTER TABLE public.movimento_item DISABLE TRIGGER trg_gera_ingressos;



pg_restore: creating FK CONSTRAINT "public.ingresso assento_ingresso_fk"
pg_restore: [archiver (db)] Error from TOC entry 6426; 2606 49606698 FK CONSTRAINT ingresso assento_ingresso_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "assento_ingresso_fk" for relation "ingresso" already exists
    Command was: ALTER TABLE ONLY public.ingresso
    ADD CONSTRAINT assento_ingresso_fk FOREIGN KEY (seq_assento) REFERENCES public.assento(seq_assento);



pg_restore: creating FK CONSTRAINT "public.sessao bilheteria_sessao_fk"
pg_restore: [archiver (db)] Error from TOC entry 6470; 2606 49606703 FK CONSTRAINT sessao bilheteria_sessao_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "bilheteria_sessao_fk" for relation "sessao" already exists
    Command was: ALTER TABLE ONLY public.sessao
    ADD CONSTRAINT bilheteria_sessao_fk FOREIGN KEY (seq_bilheteria) REFERENCES public.bilheteria(seq_bilheteria);



pg_restore: creating FK CONSTRAINT "public.matricula cadeira_matricula_fk"
pg_restore: [archiver (db)] Error from TOC entry 6433; 2606 49606708 FK CONSTRAINT matricula cadeira_matricula_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "cadeira_matricula_fk" for relation "matricula" already exists
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT cadeira_matricula_fk FOREIGN KEY (seq_cadeira) REFERENCES public.cadeira(seq_cadeira) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.matricula camarote_matricula_fk"
pg_restore: [archiver (db)] Error from TOC entry 6432; 2606 49606713 FK CONSTRAINT matricula camarote_matricula_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "camarote_matricula_fk" for relation "matricula" already exists
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT camarote_matricula_fk FOREIGN KEY (seq_camarote) REFERENCES public.camarote(seq_camarote) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.ingresso cartao_ingresso_fk"
pg_restore: [archiver (db)] Error from TOC entry 6425; 2606 49606718 FK CONSTRAINT ingresso cartao_ingresso_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "cartao_ingresso_fk" for relation "ingresso" already exists
    Command was: ALTER TABLE ONLY public.ingresso
    ADD CONSTRAINT cartao_ingresso_fk FOREIGN KEY (seq_cartao) REFERENCES public.cartao(seq_cartao);



pg_restore: creating FK CONSTRAINT "public.produto_catraca catraca_produto_catraca_fk"
pg_restore: [archiver (db)] Error from TOC entry 6462; 2606 49606723 FK CONSTRAINT produto_catraca catraca_produto_catraca_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "catraca_produto_catraca_fk" for relation "produto_catraca" already exists
    Command was: ALTER TABLE ONLY public.produto_catraca
    ADD CONSTRAINT catraca_produto_catraca_fk FOREIGN KEY (seq_catraca) REFERENCES public.catraca(seq_catraca) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.evento clube_evento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6419; 2606 49606728 FK CONSTRAINT evento clube_evento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "clube_evento_fk" for relation "evento" already exists
    Command was: ALTER TABLE ONLY public.evento
    ADD CONSTRAINT clube_evento_fk FOREIGN KEY (seq_clube_adversario) REFERENCES public.clube(seq_clube);



pg_restore: creating FK CONSTRAINT "public.cobranca_titulo cobranca_retorno_cobranca_titulo_fk"
pg_restore: [archiver (db)] Error from TOC entry 6411; 2606 49606733 FK CONSTRAINT cobranca_titulo cobranca_retorno_cobranca_titulo_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "cobranca_retorno_cobranca_titulo_fk" for relation "cobranca_titulo" already exists
    Command was: ALTER TABLE ONLY public.cobranca_titulo
    ADD CONSTRAINT cobranca_retorno_cobranca_titulo_fk FOREIGN KEY (seq_cobranca_retorno) REFERENCES public.cobranca_retorno(seq_cobranca_retorno) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.cobranca_titulo_item cobranca_titulo_cobranca_titulo_item_fk"
pg_restore: [archiver (db)] Error from TOC entry 6413; 2606 49606738 FK CONSTRAINT cobranca_titulo_item cobranca_titulo_cobranca_titulo_item_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "cobranca_titulo_cobranca_titulo_item_fk" for relation "cobranca_titulo_item" already exists
    Command was: ALTER TABLE ONLY public.cobranca_titulo_item
    ADD CONSTRAINT cobranca_titulo_cobranca_titulo_item_fk FOREIGN KEY (seq_cobranca_titulo) REFERENCES public.cobranca_titulo(seq_cobranca_titulo) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.cobranca_titulo_item cobranca_titulo_item_seq_movimento_cobranca_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6412; 2606 49606743 FK CONSTRAINT cobranca_titulo_item cobranca_titulo_item_seq_movimento_cobranca_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "cobranca_titulo_item_seq_movimento_cobranca_fkey" for relation "cobranca_titulo_item" already exists
    Command was: ALTER TABLE ONLY public.cobranca_titulo_item
    ADD CONSTRAINT cobranca_titulo_item_seq_movimento_cobranca_fkey FOREIGN KEY (seq_movimento_cobranca) REFERENCES public.movimento_cobranca(seq_movimento_cobranca) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.competicao_edicao competicao_competicao_edicao_fk"
pg_restore: [archiver (db)] Error from TOC entry 6414; 2606 49606748 FK CONSTRAINT competicao_edicao competicao_competicao_edicao_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "competicao_competicao_edicao_fk" for relation "competicao_edicao" already exists
    Command was: ALTER TABLE ONLY public.competicao_edicao
    ADD CONSTRAINT competicao_competicao_edicao_fk FOREIGN KEY (seq_competicao) REFERENCES public.competicao(seq_competicao);



pg_restore: creating FK CONSTRAINT "public.evento_produto evento_evento_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6421; 2606 49606753 FK CONSTRAINT evento_produto evento_evento_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "evento_evento_produto_fk" for relation "evento_produto" already exists
    Command was: ALTER TABLE ONLY public.evento_produto
    ADD CONSTRAINT evento_evento_produto_fk FOREIGN KEY (seq_evento) REFERENCES public.evento(seq_evento);



pg_restore: creating FK CONSTRAINT "public.evento evento_local_evento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6418; 2606 49606758 FK CONSTRAINT evento evento_local_evento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "evento_local_evento_fk" for relation "evento" already exists
    Command was: ALTER TABLE ONLY public.evento
    ADD CONSTRAINT evento_local_evento_fk FOREIGN KEY (seq_evento_local) REFERENCES public.evento_local(seq_evento_local);



pg_restore: creating FK CONSTRAINT "public.evento evento_objetivo"
pg_restore: [archiver (db)] Error from TOC entry 6417; 2606 49606763 FK CONSTRAINT evento evento_objetivo postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "evento_objetivo" for relation "evento" already exists
    Command was: ALTER TABLE ONLY public.evento
    ADD CONSTRAINT evento_objetivo FOREIGN KEY (objetivo) REFERENCES public.evento_objetivo(seq_evento_objetivo);



pg_restore: creating FK CONSTRAINT "public.sessao_evento_produto evento_produto_sessao_evento_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6473; 2606 49606768 FK CONSTRAINT sessao_evento_produto evento_produto_sessao_evento_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "evento_produto_sessao_evento_produto_fk" for relation "sessao_evento_produto" already exists
    Command was: ALTER TABLE ONLY public.sessao_evento_produto
    ADD CONSTRAINT evento_produto_sessao_evento_produto_fk FOREIGN KEY (seq_evento_produto) REFERENCES public.evento_produto(seq_evento_produto);



pg_restore: creating FK CONSTRAINT "public.evento evento_seq_competicao_edicao_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6416; 2606 49606773 FK CONSTRAINT evento evento_seq_competicao_edicao_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "evento_seq_competicao_edicao_fkey" for relation "evento" already exists
    Command was: ALTER TABLE ONLY public.evento
    ADD CONSTRAINT evento_seq_competicao_edicao_fkey FOREIGN KEY (seq_competicao_edicao) REFERENCES public.competicao_edicao(seq_competicao_edicao);



pg_restore: creating FK CONSTRAINT "public.conta fk_conta_conta_pai"
pg_restore: [archiver (db)] Error from TOC entry 6415; 2606 49606778 FK CONSTRAINT conta fk_conta_conta_pai postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "fk_conta_conta_pai" for relation "conta" already exists
    Command was: ALTER TABLE ONLY public.conta
    ADD CONSTRAINT fk_conta_conta_pai FOREIGN KEY (conta_pai) REFERENCES public.conta(seq_conta) ON UPDATE RESTRICT ON DELETE RESTRICT;



pg_restore: creating FK CONSTRAINT "public.produto fk_produto_configuracao"
pg_restore: [archiver (db)] Error from TOC entry 6460; 2606 49606783 FK CONSTRAINT produto fk_produto_configuracao postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "fk_produto_configuracao" for relation "produto" already exists
    Command was: ALTER TABLE ONLY public.produto
    ADD CONSTRAINT fk_produto_configuracao FOREIGN KEY (seq_produto_configuracao) REFERENCES public.produto_configuracao(seq_produto_configuracao);



pg_restore: creating FK CONSTRAINT "public.meio_pagamento forma_pagamento_meio_pagamento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6437; 2606 49606788 FK CONSTRAINT meio_pagamento forma_pagamento_meio_pagamento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "forma_pagamento_meio_pagamento_fk" for relation "meio_pagamento" already exists
    Command was: ALTER TABLE ONLY public.meio_pagamento
    ADD CONSTRAINT forma_pagamento_meio_pagamento_fk FOREIGN KEY (seq_forma_pagamento) REFERENCES public.forma_pagamento(seq_forma_pagamento);



pg_restore: creating FK CONSTRAINT "public.pessoa_dados_pagamento forma_pagamento_pessoa_dados_pagamento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6454; 2606 49606793 FK CONSTRAINT pessoa_dados_pagamento forma_pagamento_pessoa_dados_pagamento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "forma_pagamento_pessoa_dados_pagamento_fk" for relation "pessoa_dados_pagamento" already exists
    Command was: ALTER TABLE ONLY public.pessoa_dados_pagamento
    ADD CONSTRAINT forma_pagamento_pessoa_dados_pagamento_fk FOREIGN KEY (seq_forma_pagamento) REFERENCES public.forma_pagamento(seq_forma_pagamento) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.ingresso ingresso_ingresso_fk"
pg_restore: [archiver (db)] Error from TOC entry 6424; 2606 49606798 FK CONSTRAINT ingresso ingresso_ingresso_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "ingresso_ingresso_fk" for relation "ingresso" already exists
    Command was: ALTER TABLE ONLY public.ingresso
    ADD CONSTRAINT ingresso_ingresso_fk FOREIGN KEY (seq_ingresso_vinculo) REFERENCES public.ingresso(seq_ingresso);



pg_restore: creating FK CONSTRAINT "public.ingresso ingresso_movimento_item_fk"
pg_restore: [archiver (db)] Error from TOC entry 6423; 2606 49606803 FK CONSTRAINT ingresso ingresso_movimento_item_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "ingresso_movimento_item_fk" for relation "ingresso" already exists
    Command was: ALTER TABLE ONLY public.ingresso
    ADD CONSTRAINT ingresso_movimento_item_fk FOREIGN KEY (seq_movimento_item) REFERENCES public.movimento_item(seq_movimento_item);



pg_restore: creating FK CONSTRAINT "public.pessoa_dados_pagamento instituicao_financeira_pessoa_dados_pagamento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6453; 2606 49606808 FK CONSTRAINT pessoa_dados_pagamento instituicao_financeira_pessoa_dados_pagamento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "instituicao_financeira_pessoa_dados_pagamento_fk" for relation "pessoa_dados_pagamento" already exists
    Command was: ALTER TABLE ONLY public.pessoa_dados_pagamento
    ADD CONSTRAINT instituicao_financeira_pessoa_dados_pagamento_fk FOREIGN KEY (seq_instituicao_financeira) REFERENCES public.instituicao_financeira(seq_instituicao_financeira) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.liberacao liberacao_seq_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6427; 2606 49606813 FK CONSTRAINT liberacao liberacao_seq_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "liberacao_seq_produto_fk" for relation "liberacao" already exists
    Command was: ALTER TABLE ONLY public.liberacao
    ADD CONSTRAINT liberacao_seq_produto_fk FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto);



pg_restore: creating FK CONSTRAINT "public.cartao matricula_cartao_fk"
pg_restore: [archiver (db)] Error from TOC entry 6408; 2606 49606818 FK CONSTRAINT cartao matricula_cartao_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "matricula_cartao_fk" for relation "cartao" already exists
    Command was: ALTER TABLE ONLY public.cartao
    ADD CONSTRAINT matricula_cartao_fk FOREIGN KEY (matricula) REFERENCES public.matricula(matricula) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento_cobranca matricula_matricula_cobranca_fk"
pg_restore: [archiver (db)] Error from TOC entry 6436; 2606 49606823 FK CONSTRAINT movimento_cobranca matricula_matricula_cobranca_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "matricula_matricula_cobranca_fk" for relation "movimento_cobranca" already exists
    Command was: ALTER TABLE ONLY public.movimento_cobranca
    ADD CONSTRAINT matricula_matricula_cobranca_fk FOREIGN KEY (matricula) REFERENCES public.matricula(matricula) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.obs_matricula matricula_obs_matricula_fk"
pg_restore: [archiver (db)] Error from TOC entry 6448; 2606 49606828 FK CONSTRAINT obs_matricula matricula_obs_matricula_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "matricula_obs_matricula_fk" for relation "obs_matricula" already exists
    Command was: ALTER TABLE ONLY public.obs_matricula
    ADD CONSTRAINT matricula_obs_matricula_fk FOREIGN KEY (matricula) REFERENCES public.matricula(matricula) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.matricula matricula_plano_pgto"
pg_restore: [archiver (db)] Error from TOC entry 6431; 2606 49606833 FK CONSTRAINT matricula matricula_plano_pgto postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "matricula_plano_pgto" for relation "matricula" already exists
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT matricula_plano_pgto FOREIGN KEY (seq_plano_pgto) REFERENCES public.plano_pgto(seq_plano_pgto);



pg_restore: creating FK CONSTRAINT "public.menu menu_objeto_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6438; 2606 49606838 FK CONSTRAINT menu menu_objeto_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "menu_objeto_fkey" for relation "menu" already exists
    Command was: ALTER TABLE ONLY public.menu
    ADD CONSTRAINT menu_objeto_fkey FOREIGN KEY (objeto) REFERENCES public.objeto(seq_objeto);



pg_restore: creating FK CONSTRAINT "public.movimento_cobranca movimento_cobranca_seq_pessoa_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6435; 2606 49606843 FK CONSTRAINT movimento_cobranca movimento_cobranca_seq_pessoa_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_cobranca_seq_pessoa_fkey" for relation "movimento_cobranca" already exists
    Command was: ALTER TABLE ONLY public.movimento_cobranca
    ADD CONSTRAINT movimento_cobranca_seq_pessoa_fkey FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento_item movimento_item_seq_movimento_cobranca_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6444; 2606 49606848 FK CONSTRAINT movimento_item movimento_item_seq_movimento_cobranca_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_item_seq_movimento_cobranca_fkey" for relation "movimento_item" already exists
    Command was: ALTER TABLE ONLY public.movimento_item
    ADD CONSTRAINT movimento_item_seq_movimento_cobranca_fkey FOREIGN KEY (seq_movimento_cobranca) REFERENCES public.movimento_cobranca(seq_movimento_cobranca) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento_item movimento_item_seq_sessao_evento_produto_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6443; 2606 49606853 FK CONSTRAINT movimento_item movimento_item_seq_sessao_evento_produto_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_item_seq_sessao_evento_produto_fkey" for relation "movimento_item" already exists
    Command was: ALTER TABLE ONLY public.movimento_item
    ADD CONSTRAINT movimento_item_seq_sessao_evento_produto_fkey FOREIGN KEY (seq_sessao_evento_produto) REFERENCES public.sessao_evento_produto(seq_sessao_evento_produto);



pg_restore: creating FK CONSTRAINT "public.movimento_item movimento_movimento_item_fk"
pg_restore: [archiver (db)] Error from TOC entry 6442; 2606 49606858 FK CONSTRAINT movimento_item movimento_movimento_item_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_movimento_item_fk" for relation "movimento_item" already exists
    Command was: ALTER TABLE ONLY public.movimento_item
    ADD CONSTRAINT movimento_movimento_item_fk FOREIGN KEY (seq_movimento) REFERENCES public.movimento(seq_movimento) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento_pagamento movimento_movimento_pagamento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6447; 2606 49606863 FK CONSTRAINT movimento_pagamento movimento_movimento_pagamento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_movimento_pagamento_fk" for relation "movimento_pagamento" already exists
    Command was: ALTER TABLE ONLY public.movimento_pagamento
    ADD CONSTRAINT movimento_movimento_pagamento_fk FOREIGN KEY (seq_movimento) REFERENCES public.movimento(seq_movimento) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento movimento_operador_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6440; 2606 49606868 FK CONSTRAINT movimento movimento_operador_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_operador_fkey" for relation "movimento" already exists
    Command was: ALTER TABLE ONLY public.movimento
    ADD CONSTRAINT movimento_operador_fkey FOREIGN KEY (operador) REFERENCES public.usuario(seq_usuario);



pg_restore: creating FK CONSTRAINT "public.movimento_pagamento movimento_pagamento_seq_forma_pagamento_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6446; 2606 49606873 FK CONSTRAINT movimento_pagamento movimento_pagamento_seq_forma_pagamento_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_pagamento_seq_forma_pagamento_fkey" for relation "movimento_pagamento" already exists
    Command was: ALTER TABLE ONLY public.movimento_pagamento
    ADD CONSTRAINT movimento_pagamento_seq_forma_pagamento_fkey FOREIGN KEY (seq_forma_pagamento) REFERENCES public.forma_pagamento(seq_forma_pagamento);



pg_restore: creating FK CONSTRAINT "public.movimento_pagamento movimento_pagamento_seq_meio_pagamento_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6445; 2606 49606878 FK CONSTRAINT movimento_pagamento movimento_pagamento_seq_meio_pagamento_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_pagamento_seq_meio_pagamento_fkey" for relation "movimento_pagamento" already exists
    Command was: ALTER TABLE ONLY public.movimento_pagamento
    ADD CONSTRAINT movimento_pagamento_seq_meio_pagamento_fkey FOREIGN KEY (seq_meio_pagamento) REFERENCES public.meio_pagamento(seq_meio_pagamento);



pg_restore: creating FK CONSTRAINT "public.movimento movimento_seq_pessoa_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6439; 2606 49606883 FK CONSTRAINT movimento movimento_seq_pessoa_fkey postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "movimento_seq_pessoa_fkey" for relation "movimento" already exists
    Command was: ALTER TABLE ONLY public.movimento
    ADD CONSTRAINT movimento_seq_pessoa_fkey FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa);



pg_restore: creating FK CONSTRAINT "public.perfil_objeto objeto_perfil_objeto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6450; 2606 49606888 FK CONSTRAINT perfil_objeto objeto_perfil_objeto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "objeto_perfil_objeto_fk" for relation "perfil_objeto" already exists
    Command was: ALTER TABLE ONLY public.perfil_objeto
    ADD CONSTRAINT objeto_perfil_objeto_fk FOREIGN KEY (seq_objeto) REFERENCES public.objeto(seq_objeto);



pg_restore: creating FK CONSTRAINT "public.perfil_objeto perfil_perfil_objeto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6449; 2606 49606893 FK CONSTRAINT perfil_objeto perfil_perfil_objeto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "perfil_perfil_objeto_fk" for relation "perfil_objeto" already exists
    Command was: ALTER TABLE ONLY public.perfil_objeto
    ADD CONSTRAINT perfil_perfil_objeto_fk FOREIGN KEY (seq_perfil) REFERENCES public.perfil(seq_perfil);



pg_restore: creating FK CONSTRAINT "public.usuario perfil_usuario_fk"
pg_restore: [archiver (db)] Error from TOC entry 6478; 2606 49606898 FK CONSTRAINT usuario perfil_usuario_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "perfil_usuario_fk" for relation "usuario" already exists
    Command was: ALTER TABLE ONLY public.usuario
    ADD CONSTRAINT perfil_usuario_fk FOREIGN KEY (seq_perfil) REFERENCES public.perfil(seq_perfil);



pg_restore: creating FK CONSTRAINT "public.matricula pessoa_dados_pagamento_matricula"
pg_restore: [archiver (db)] Error from TOC entry 6430; 2606 49606903 FK CONSTRAINT matricula pessoa_dados_pagamento_matricula postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_dados_pagamento_matricula" for relation "matricula" already exists
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT pessoa_dados_pagamento_matricula FOREIGN KEY (seq_pessoa_dados_pagamento) REFERENCES public.pessoa_dados_pagamento(seq_pessoa_dados_pagamento);



pg_restore: creating FK CONSTRAINT "public.ingresso pessoa_ingresso_fk"
pg_restore: [archiver (db)] Error from TOC entry 6422; 2606 49606908 FK CONSTRAINT ingresso pessoa_ingresso_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_ingresso_fk" for relation "ingresso" already exists
    Command was: ALTER TABLE ONLY public.ingresso
    ADD CONSTRAINT pessoa_ingresso_fk FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa);



pg_restore: creating FK CONSTRAINT "public.matricula pessoa_matricula_fk"
pg_restore: [archiver (db)] Error from TOC entry 6429; 2606 49606913 FK CONSTRAINT matricula pessoa_matricula_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_matricula_fk" for relation "matricula" already exists
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT pessoa_matricula_fk FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.pessoa_dados_pagamento pessoa_pessoa_dados_pagamento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6452; 2606 49606918 FK CONSTRAINT pessoa_dados_pagamento pessoa_pessoa_dados_pagamento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_pessoa_dados_pagamento_fk" for relation "pessoa_dados_pagamento" already exists
    Command was: ALTER TABLE ONLY public.pessoa_dados_pagamento
    ADD CONSTRAINT pessoa_pessoa_dados_pagamento_fk FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.usuario pessoa_usuario_fk"
pg_restore: [archiver (db)] Error from TOC entry 6477; 2606 49606923 FK CONSTRAINT usuario pessoa_usuario_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_usuario_fk" for relation "usuario" already exists
    Command was: ALTER TABLE ONLY public.usuario
    ADD CONSTRAINT pessoa_usuario_fk FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa);



pg_restore: creating FK CONSTRAINT "public.pessoa_vinculo pessoa_vinculo_pessoa_fk"
pg_restore: [archiver (db)] Error from TOC entry 6456; 2606 49606928 FK CONSTRAINT pessoa_vinculo pessoa_vinculo_pessoa_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_vinculo_pessoa_fk" for relation "pessoa_vinculo" already exists
    Command was: ALTER TABLE ONLY public.pessoa_vinculo
    ADD CONSTRAINT pessoa_vinculo_pessoa_fk FOREIGN KEY (seq_pessoa) REFERENCES public.pessoa(seq_pessoa);



pg_restore: creating FK CONSTRAINT "public.pessoa_vinculo pessoa_vinculo_vinculo_fk"
pg_restore: [archiver (db)] Error from TOC entry 6455; 2606 49606933 FK CONSTRAINT pessoa_vinculo pessoa_vinculo_vinculo_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "pessoa_vinculo_vinculo_fk" for relation "pessoa_vinculo" already exists
    Command was: ALTER TABLE ONLY public.pessoa_vinculo
    ADD CONSTRAINT pessoa_vinculo_vinculo_fk FOREIGN KEY (seq_vinculo) REFERENCES public.vinculo(seq_vinculo);



pg_restore: creating FK CONSTRAINT "public.plano_pgto plano_pgto_seq_produto_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6457; 2606 49606938 FK CONSTRAINT plano_pgto plano_pgto_seq_produto_fkey acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "plano_pgto_seq_produto_fkey" for relation "plano_pgto" already exists
    Command was: ALTER TABLE ONLY public.plano_pgto
    ADD CONSTRAINT plano_pgto_seq_produto_fkey FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto);



pg_restore: creating FK CONSTRAINT "public.catraca portao_catraca_fk"
pg_restore: [archiver (db)] Error from TOC entry 6409; 2606 49606943 FK CONSTRAINT catraca portao_catraca_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "portao_catraca_fk" for relation "catraca" already exists
    Command was: ALTER TABLE ONLY public.catraca
    ADD CONSTRAINT portao_catraca_fk FOREIGN KEY (seq_portao) REFERENCES public.portao(seq_portao) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.produto produto_contrato_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6459; 2606 49606948 FK CONSTRAINT produto produto_contrato_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_contrato_produto_fk" for relation "produto" already exists
    Command was: ALTER TABLE ONLY public.produto
    ADD CONSTRAINT produto_contrato_produto_fk FOREIGN KEY (seq_produto_contrato) REFERENCES public.produto_contrato(seq_produto_contrato) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.evento_produto produto_evento_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6420; 2606 49606953 FK CONSTRAINT evento_produto produto_evento_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_evento_produto_fk" for relation "evento_produto" already exists
    Command was: ALTER TABLE ONLY public.evento_produto
    ADD CONSTRAINT produto_evento_produto_fk FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto);



pg_restore: creating FK CONSTRAINT "public.matricula produto_matricula_fk"
pg_restore: [archiver (db)] Error from TOC entry 6428; 2606 49606958 FK CONSTRAINT matricula produto_matricula_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_matricula_fk" for relation "matricula" already exists
    Command was: ALTER TABLE ONLY public.matricula
    ADD CONSTRAINT produto_matricula_fk FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.produto_plano_pgto produto_plano_pgto_seq_plano_pgto_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6464; 2606 49606963 FK CONSTRAINT produto_plano_pgto produto_plano_pgto_seq_plano_pgto_fkey acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_plano_pgto_seq_plano_pgto_fkey" for relation "produto_plano_pgto" already exists
    Command was: ALTER TABLE ONLY public.produto_plano_pgto
    ADD CONSTRAINT produto_plano_pgto_seq_plano_pgto_fkey FOREIGN KEY (seq_plano_pgto) REFERENCES public.plano_pgto(seq_plano_pgto);



pg_restore: creating FK CONSTRAINT "public.produto_plano_pgto produto_plano_pgto_seq_produto_taxa_fkey"
pg_restore: [archiver (db)] Error from TOC entry 6463; 2606 49606968 FK CONSTRAINT produto_plano_pgto produto_plano_pgto_seq_produto_taxa_fkey acbf
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_plano_pgto_seq_produto_taxa_fkey" for relation "produto_plano_pgto" already exists
    Command was: ALTER TABLE ONLY public.produto_plano_pgto
    ADD CONSTRAINT produto_plano_pgto_seq_produto_taxa_fkey FOREIGN KEY (seq_produto_taxa) REFERENCES public.produto_taxa(seq_produto_taxa);



pg_restore: creating FK CONSTRAINT "public.produto_catraca produto_produto_catraca_fk"
pg_restore: [archiver (db)] Error from TOC entry 6461; 2606 49606973 FK CONSTRAINT produto_catraca produto_produto_catraca_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_produto_catraca_fk" for relation "produto_catraca" already exists
    Command was: ALTER TABLE ONLY public.produto_catraca
    ADD CONSTRAINT produto_produto_catraca_fk FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.produto_taxa produto_produto_taxa_fk"
pg_restore: [archiver (db)] Error from TOC entry 6466; 2606 49606978 FK CONSTRAINT produto_taxa produto_produto_taxa_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  insert or update on table "produto_taxa" violates foreign key constraint "produto_produto_taxa_fk"
DETAIL:  Key (seq_produto)=(331) is not present in table "produto".
    Command was: ALTER TABLE ONLY public.produto_taxa
    ADD CONSTRAINT produto_produto_taxa_fk FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.produto_escolinha_turma produto_produto_taxa_fk"
pg_restore: [archiver (db)] Error from TOC entry 6479; 2606 49893180 FK CONSTRAINT produto_escolinha_turma produto_produto_taxa_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_produto_taxa_fk" for relation "produto_escolinha_turma" already exists
    Command was: ALTER TABLE ONLY public.produto_escolinha_turma
    ADD CONSTRAINT produto_produto_taxa_fk FOREIGN KEY (seq_produto) REFERENCES public.produto(seq_produto) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento_cobranca produto_taxa_matricula_cobranca_fk"
pg_restore: [archiver (db)] Error from TOC entry 6434; 2606 49606983 FK CONSTRAINT movimento_cobranca produto_taxa_matricula_cobranca_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_taxa_matricula_cobranca_fk" for relation "movimento_cobranca" already exists
    Command was: ALTER TABLE ONLY public.movimento_cobranca
    ADD CONSTRAINT produto_taxa_matricula_cobranca_fk FOREIGN KEY (seq_produto_taxa) REFERENCES public.produto_taxa(seq_produto_taxa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.movimento_item produto_taxa_movimento_item_fk"
pg_restore: [archiver (db)] Error from TOC entry 6441; 2606 49606988 FK CONSTRAINT movimento_item produto_taxa_movimento_item_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "produto_taxa_movimento_item_fk" for relation "movimento_item" already exists
    Command was: ALTER TABLE ONLY public.movimento_item
    ADD CONSTRAINT produto_taxa_movimento_item_fk FOREIGN KEY (seq_produto_taxa) REFERENCES public.produto_taxa(seq_produto_taxa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.pessoa profissao_pessoa_fk"
pg_restore: [archiver (db)] Error from TOC entry 6451; 2606 49606993 FK CONSTRAINT pessoa profissao_pessoa_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "profissao_pessoa_fk" for relation "pessoa" already exists
    Command was: ALTER TABLE ONLY public.pessoa
    ADD CONSTRAINT profissao_pessoa_fk FOREIGN KEY (seq_profissao) REFERENCES public.profissao(seq_profissao) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.cobranca_titulo remessa_cobranca_titulo_fk"
pg_restore: [archiver (db)] Error from TOC entry 6410; 2606 49606998 FK CONSTRAINT cobranca_titulo remessa_cobranca_titulo_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "remessa_cobranca_titulo_fk" for relation "cobranca_titulo" already exists
    Command was: ALTER TABLE ONLY public.cobranca_titulo
    ADD CONSTRAINT remessa_cobranca_titulo_fk FOREIGN KEY (seq_remessa) REFERENCES public.remessa(seq_remessa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.sangria sessao_sangria_fk"
pg_restore: [archiver (db)] Error from TOC entry 6468; 2606 49607003 FK CONSTRAINT sangria sessao_sangria_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "sessao_sangria_fk" for relation "sangria" already exists
    Command was: ALTER TABLE ONLY public.sangria
    ADD CONSTRAINT sessao_sangria_fk FOREIGN KEY (seq_sessao) REFERENCES public.sessao(seq_sessao);



pg_restore: creating FK CONSTRAINT "public.sessao_evento_produto sessao_sessao_evento_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6472; 2606 49607008 FK CONSTRAINT sessao_evento_produto sessao_sessao_evento_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "sessao_sessao_evento_produto_fk" for relation "sessao_evento_produto" already exists
    Command was: ALTER TABLE ONLY public.sessao_evento_produto
    ADD CONSTRAINT sessao_sessao_evento_produto_fk FOREIGN KEY (seq_sessao) REFERENCES public.sessao(seq_sessao);



pg_restore: creating FK CONSTRAINT "public.troco sessao_troco_fk"
pg_restore: [archiver (db)] Error from TOC entry 6475; 2606 49607013 FK CONSTRAINT troco sessao_troco_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "sessao_troco_fk" for relation "troco" already exists
    Command was: ALTER TABLE ONLY public.troco
    ADD CONSTRAINT sessao_troco_fk FOREIGN KEY (seq_sessao) REFERENCES public.sessao(seq_sessao);



pg_restore: creating FK CONSTRAINT "public.assento setor_assento_fk"
pg_restore: [archiver (db)] Error from TOC entry 6407; 2606 49607018 FK CONSTRAINT assento setor_assento_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "setor_assento_fk" for relation "assento" already exists
    Command was: ALTER TABLE ONLY public.assento
    ADD CONSTRAINT setor_assento_fk FOREIGN KEY (seq_setor) REFERENCES public.setor(seq_setor);



pg_restore: creating FK CONSTRAINT "public.portao setor_portao_fk"
pg_restore: [archiver (db)] Error from TOC entry 6458; 2606 49607023 FK CONSTRAINT portao setor_portao_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "setor_portao_fk" for relation "portao" already exists
    Command was: ALTER TABLE ONLY public.portao
    ADD CONSTRAINT setor_portao_fk FOREIGN KEY (seq_setor) REFERENCES public.setor(seq_setor) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.produto_taxa taxa_produto_taxa_fk"
pg_restore: [archiver (db)] Error from TOC entry 6465; 2606 49607028 FK CONSTRAINT produto_taxa taxa_produto_taxa_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  insert or update on table "produto_taxa" violates foreign key constraint "taxa_produto_taxa_fk"
DETAIL:  Key (seq_taxa)=(1) is not present in table "taxa".
    Command was: ALTER TABLE ONLY public.produto_taxa
    ADD CONSTRAINT taxa_produto_taxa_fk FOREIGN KEY (seq_taxa) REFERENCES public.taxa(seq_taxa) ON UPDATE CASCADE;



pg_restore: creating FK CONSTRAINT "public.sangria usuario_sangria_fk"
pg_restore: [archiver (db)] Error from TOC entry 6467; 2606 49607033 FK CONSTRAINT sangria usuario_sangria_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "usuario_sangria_fk" for relation "sangria" already exists
    Command was: ALTER TABLE ONLY public.sangria
    ADD CONSTRAINT usuario_sangria_fk FOREIGN KEY (seq_supervisor) REFERENCES public.usuario(seq_usuario);



pg_restore: creating FK CONSTRAINT "public.sessao_evento_produto usuario_sessao_evento_produto_fk"
pg_restore: [archiver (db)] Error from TOC entry 6471; 2606 49607038 FK CONSTRAINT sessao_evento_produto usuario_sessao_evento_produto_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "usuario_sessao_evento_produto_fk" for relation "sessao_evento_produto" already exists
    Command was: ALTER TABLE ONLY public.sessao_evento_produto
    ADD CONSTRAINT usuario_sessao_evento_produto_fk FOREIGN KEY (seq_supervisor) REFERENCES public.usuario(seq_usuario);



pg_restore: creating FK CONSTRAINT "public.sessao usuario_sessao_fk"
pg_restore: [archiver (db)] Error from TOC entry 6469; 2606 49607043 FK CONSTRAINT sessao usuario_sessao_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "usuario_sessao_fk" for relation "sessao" already exists
    Command was: ALTER TABLE ONLY public.sessao
    ADD CONSTRAINT usuario_sessao_fk FOREIGN KEY (seq_bilheteiro) REFERENCES public.usuario(seq_usuario);



pg_restore: creating FK CONSTRAINT "public.usuario usuario_tipo_usuario_fk"
pg_restore: [archiver (db)] Error from TOC entry 6476; 2606 49607048 FK CONSTRAINT usuario usuario_tipo_usuario_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "usuario_tipo_usuario_fk" for relation "usuario" already exists
    Command was: ALTER TABLE ONLY public.usuario
    ADD CONSTRAINT usuario_tipo_usuario_fk FOREIGN KEY (seq_usuario_tipo) REFERENCES public.usuario_tipo(seq_usuario_tipo);



pg_restore: creating FK CONSTRAINT "public.troco usuario_troco_fk"
pg_restore: [archiver (db)] Error from TOC entry 6474; 2606 49607053 FK CONSTRAINT troco usuario_troco_fk postgres
pg_restore: [archiver (db)] could not execute query: ERROR:  constraint "usuario_troco_fk" for relation "troco" already exists
    Command was: ALTER TABLE ONLY public.troco
    ADD CONSTRAINT usuario_troco_fk FOREIGN KEY (seq_supervisor) REFERENCES public.usuario(seq_usuario);



WARNING: errors ignored on restore: 394