Liste todas as seqüências em um Postgres db 8.1 com SQL

Question

Eu estou convertendo um db de postgres para mysql.

Uma vez que eu não posso encontrar uma ferramenta que faz o próprio truque, eu estou indo para converter todos postgres seqüências para autoincrement ids no mysql com autoincrement valor.

Então, como posso listar todas as seqüências em um Postgres DB ( 8,1 Versão) com informações sobre a mesa em que ele é usado, o valor seguinte etc com um SQL consulta?

Esteja ciente de que eu não posso usar a visão information_schema.sequences na versão 8.4.

Answer 1

A consulta a seguir dá nomes de todas as seqüências.

SELECT c.relname FROM pg_class c WHERE c.relkind = 'S';

Tipicamente uma sequência é designada como ${table}_id_seq. Teste padrão simples regex correspondência vai dar-lhe o nome da tabela.

Para obter o último valor de um uso seqüência a seguinte consulta:

SELECT last_value FROM test_id_seq;

Answer 2

Note, que a partir de PostgreSQL 8.4 você pode obter todas informações sobre as seqüências usadas no banco de dados via:

SELECT * FROM information_schema.sequences;

---

Desde que eu estou usando uma versão superior do PostgreSQL (9.1), e estava à procura de mesma alta resposta e baixo, eu adicionei essa resposta para a posteridade e para os futuros pesquisadores.

Answer 3

Run: psql -E, e depois \ds

Answer 4

depois de um pouco de dor, eu consegui isso.

a melhor maneira de conseguir isso é listar todas as tabelas

select * from pg_tables where schemaname = '<schema_name>'

e, em seguida, para cada tabela, listar todas as colunas com atributos

select * from information_schema.columns where table_name = '<table_name>'

, em seguida, para cada coluna, teste se tem uma sequência

select pg_get_serial_sequence('<table_name>', '<column_name>')

e, em seguida, obter as informações sobre essa sequência

select * from <sequence_name>

Answer 5

A relação entre sequências geradas automaticamente (tais como os criados por colunas em série) e tabela pai é modelada pelo atributo proprietário sequência.

Você pode modificar esse relacionamento usando o OWNED BY cláusula do ALTER SEQUENCE commmand

por exemplo. ALTER SEQUENCE foo_id POSSUÍDO por foo_schema.foo_table

para configurá-lo para ser ligado ao foo_table tabela

ou ALTER SEQUENCE foo_id POSSUÍDO por NONE

para quebrar a ligação entre a sequência e qualquer mesa

As informações sobre esta relação é armazenada em href="http://www.postgresql.org/docs/8.4/static/catalog-pg-depend.html" rel="noreferrer"> tabela de .

a relação de junção é a ligação entre pg_depend.objid -> pg_class.oid ONDE relkind = 'S' -, que liga a sequência para o juntar ficha e, em seguida, pg_depend.refobjid -> pg_class.oid ONDE relkind = 'r', que liga o registro para a possuir relação (tabela) join

Esta consulta retorna todos a seqüência - dependências> tabela em um banco de dados. A cláusula WHERE filtra para incluir apenas as relações auto gerada, o que restringe a apenas seqüências de exibição criados por SERIAL digitadas colunas.

WITH fq_objects AS (SELECT c.oid,n.nspname || '.' ||c.relname AS fqname , 
                           c.relkind, c.relname AS relation 
                    FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace ),

     sequences AS (SELECT oid,fqname FROM fq_objects WHERE relkind = 'S'),  
     tables    AS (SELECT oid, fqname FROM fq_objects WHERE relkind = 'r' )  
SELECT
       s.fqname AS sequence, 
       '->' as depends, 
       t.fqname AS table 
FROM 
     pg_depend d JOIN sequences s ON s.oid = d.objid  
                 JOIN tables t ON t.oid = d.refobjid  
WHERE 
     d.deptype = 'a' ;

Answer 6

info seqüência: valor máximo

SELECT * FROM information_schema.sequences;

info seqüência: último valor

SELECT * FROM <sequence_name>

Answer 7

Eu sei que este post é muito velho, mas eu encontrei a solução por CMS para ser muito útil como eu estava procurando para uma forma automatizada para vincular uma seqüência para a mesa e coluna, e queria compartilhar. O uso de pg_depend tabela do catálogo era a chave. I expandida que foi feito para:

WITH fq_objects AS (SELECT c.oid,n.nspname || '.' ||c.relname AS fqname ,
                           c.relkind, c.relname AS relation
                    FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace ),

     sequences AS (SELECT oid,fqname FROM fq_objects WHERE relkind = 'S'),
     tables    AS (SELECT oid, fqname FROM fq_objects WHERE relkind = 'r' )
SELECT
       s.fqname AS sequence,
       '->' as depends,
       t.fqname AS table,
       a.attname AS column
FROM
     pg_depend d JOIN sequences s ON s.oid = d.objid
                 JOIN tables t ON t.oid = d.refobjid
                 JOIN pg_attribute a ON a.attrelid = d.refobjid and a.attnum = d.refobjsubid
WHERE
     d.deptype = 'a' ;

Esta versão acrescenta coluna para a lista de campos retornados. Com tanto o nome da tabela eo nome da coluna na mão, uma chamada para pg_set_serial_sequence torna mais fácil para garantir que todas as seqüências no banco de dados estão definidos corretamente. Por exemplo:

CREATE OR REPLACE FUNCTION public.reset_sequence(tablename text, columnname text)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
DECLARE
    _sql VARCHAR := '';
BEGIN
    _sql := $$SELECT setval( pg_get_serial_sequence('$$ || tablename || $$', '$$ || columnname || $$'), (SELECT COALESCE(MAX($$ || columnname || $$),1) FROM $$ || tablename || $$), true)$$;
    EXECUTE _sql;
END;
$function$;

Espero que isso ajude alguém com a redefinição seqüências!

Answer 8

parcialmente testado, mas parece quase completo.

select *
  from (select n.nspname,c.relname,
               (select substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid) for 128)
                  from pg_catalog.pg_attrdef d
                 where d.adrelid=a.attrelid
                   and d.adnum=a.attnum
                   and a.atthasdef) as def
          from pg_class c, pg_attribute a, pg_namespace n
         where c.relkind='r'
           and c.oid=a.attrelid
           and n.oid=c.relnamespace
           and a.atthasdef
           and a.atttypid=20) x
 where x.def ~ '^nextval'
 order by nspname,relname;

Crédito onde o crédito é devido ... é, em parte, a engenharia reversa do SQL registrada a partir de um \ d em uma mesa sabido que tinha uma seqüência. Tenho certeza de que poderia ser mais limpas também, mas hey, o desempenho não foi uma preocupação.

Answer 9

Uma espécie de truque, mas tente o seguinte:

selecione 'selecionar ''' || relname || '' 'Como sequência, last_value de' || relname || ' União' DE pg_catalog.pg_class c ONDE c.relkind IN ( 'S', '');

Remova a última UNIÃO e executar o resultado

Answer 10

A melhoria da resposta anterior:

select string_agg('select sequence_name, last_value from ' || relname, chr(13) || 'union' || chr(13) order by relname) 
from pg_class where relkind ='S'

Answer 11

Esta declaração listas da tabela e coluna que está associado com cada seqüência:

Código:

    SELECT t.relname as related_table, 
           a.attname as related_column,
           s.relname as sequence_name
    FROM pg_class s 
      JOIN pg_depend d ON d.objid = s.oid 
      JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid 
      JOIN pg_attribute a ON (d.refobjid, d.refobjsubid) = (a.attrelid, a.attnum)
      JOIN pg_namespace n ON n.oid = s.relnamespace 
    WHERE s.relkind     = 'S' 

  AND n.nspname     = 'public'

mais ver aqui link para resposta

Answer 12

Obter sequências por cada coluna de cada tabela através de análise de cláusula PADRÃO. Este método fornece informação sobre a que as sequências de coluna estão ligados e não usa dependências que não pode existem para algumas sequências. Mesmo função pg_get_serial_sequence(sch.nspname||'.'||tbl.relname, col.attname) encontrados não todos seqüências para mim!

Solução:

SELECT
    seq_sch.nspname  AS sequence_schema
  , seq.relname      AS sequence_name
  , seq_use."schema" AS used_in_schema
  , seq_use."table"  AS used_in_table
  , seq_use."column" AS used_in_column
FROM pg_class seq
  INNER JOIN pg_namespace seq_sch ON seq_sch.oid = seq.relnamespace
  LEFT JOIN (
              SELECT
                  sch.nspname AS "schema"
                , tbl.relname AS "table"
                , col.attname AS "column"
                , regexp_split_to_array(
                      TRIM(LEADING 'nextval(''' FROM
                           TRIM(TRAILING '''::regclass)' FROM
                                pg_get_expr(def.adbin, tbl.oid, TRUE)
                           )
                      )
                      , '\.'
                  )           AS column_sequence
              FROM pg_class tbl --the table
                INNER JOIN pg_namespace sch ON sch.oid = tbl.relnamespace
                --schema
                INNER JOIN pg_attribute col ON col.attrelid = tbl.oid
                --columns
                INNER JOIN pg_attrdef def ON (def.adrelid = tbl.oid AND def.adnum = col.attnum) --default values for columns
              WHERE tbl.relkind = 'r' --regular relations (tables) only
                    AND col.attnum > 0 --regular columns only
                    AND def.adsrc LIKE 'nextval(%)' --sequences only
            ) seq_use ON (seq_use.column_sequence [1] = seq_sch.nspname AND seq_use.column_sequence [2] = seq.relname)
WHERE seq.relkind = 'S' --sequences only
ORDER BY sequence_schema, sequence_name;

Note que uma sequência pode ser usado em várias tabelas, para que ele possa ser listados em várias linhas aqui.

Answer 13

Obrigado por sua ajuda.

Aqui está o pl / pgsql função que update cada seqüência de um banco de dados.

---------------------------------------------------------------------------------------------------------
--- Nom : reset_sequence
--- Description : Générique - met à jour les séquences au max de l'identifiant
---------------------------------------------------------------------------------------------------------

CREATE OR REPLACE FUNCTION reset_sequence() RETURNS void AS 
$BODY$
DECLARE _sql VARCHAR := '';
DECLARE result threecol%rowtype; 
BEGIN
FOR result IN 
WITH fq_objects AS (SELECT c.oid,n.nspname || '.' ||c.relname AS fqname ,c.relkind, c.relname AS relation FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace ),
    sequences AS (SELECT oid,fqname FROM fq_objects WHERE relkind = 'S'),
    tables    AS (SELECT oid, fqname FROM fq_objects WHERE relkind = 'r' )
SELECT
       s.fqname AS sequence,
       t.fqname AS table,
       a.attname AS column
FROM
     pg_depend d JOIN sequences s ON s.oid = d.objid
                 JOIN tables t ON t.oid = d.refobjid
                 JOIN pg_attribute a ON a.attrelid = d.refobjid and a.attnum = d.refobjsubid
WHERE
     d.deptype = 'a' 
LOOP
     EXECUTE 'SELECT setval('''||result.col1||''', COALESCE((SELECT MAX('||result.col3||')+1 FROM '||result.col2||'), 1), false);';
END LOOP;
END;$BODY$ LANGUAGE plpgsql;

SELECT * FROM reset_sequence();

Answer 14

Aqui está um outro que tem o nome do esquema ao lado do nome da seqüência

select nspname,relname from pg_class c join pg_namespace n on c.relnamespace=n.oid where relkind = 'S' order by nspname

Answer 15

Esta página mostra o last_value de cada sequência.

Ele produz uma tabela de 2 colunas que diz que o nome da seqüência Além disso, é último valor gerado.

drop function if exists public.show_sequence_stats();
CREATE OR REPLACE FUNCTION public.show_sequence_stats()
    RETURNS TABLE(tablename text, last_value bigint) 
    LANGUAGE 'plpgsql'
    COST 100
    VOLATILE 
    ROWS 1000
AS $BODY$
declare r refcursor; rec record; dynamic_query varchar;
        BEGIN
            dynamic_query='select tablename,last_value from (';
            open r for execute 'select nspname,relname from pg_class c join pg_namespace n on c.relnamespace=n.oid where relkind = ''S'' order by nspname'; 
            fetch next from r into rec;
            while found 
            loop
                dynamic_query=dynamic_query || 'select '''|| rec.nspname || '.' || rec.relname ||''' "tablename",last_value from ' || rec.nspname || '.' || rec.relname || ' union all ';
                fetch next from r into rec; 
            end loop;
            close r; 
            dynamic_query=rtrim(dynamic_query,'union all') || ') x order by last_value desc;';
            return query execute dynamic_query;
        END;
$BODY$;

select * from show_sequence_stats();

Answer 16

Assumindo função exec() declarou neste post https://stackoverflow.com/a/46721603/653539 , seqüências juntos com seus últimos valores podem ser obtidos usando consulta única:

select s.sequence_schema, s.sequence_name,
  (select * from exec('select last_value from ' || s.sequence_schema || '.' || s.sequence_name) as e(lv bigint)) last_value
from information_schema.sequences s