Paul Draper's questions

Eu crio uma tabela com 1 milhão de registros, então eu excluo esses registros. (Comum com algum tipo de lista de processamento.)

CREATE TABLE example (id int PRIMARY KEY);
INSERT INTO example SELECT generate_series(1, 1000 * 1000);
DELETE FROM example;
VACUUM example;

O tamanho do índice permanece no mesmo tamanho de antes da exclusão.

SELECT pg_size_pretty(pg_relation_size(c.oid)) AS size
FROM pg_class c
WHERE oid = 'example_pkey'::regclass;

 size  
-------
 21 MB
(1 row)

Da mesma forma, consultas de detecção de inchaço (por exemplo , ioguix/pgsql-bloat-estimation ) identificam esse índice como extremamente inchado.

Eu não me importo com o uso do disco em si. O desempenho do índice será afetado por seu grande tamanho? Eu deveria estar correndo REINDEX?

CREATE TABLE widget (
  id serial PRIMARY KEY,
  name text NOT NULL,
  ordinal int NOT NULL UNIQUE
);

eu tenho os dados

 id | name | ordinal 
----+------+---------
  1 | A    |       1
  2 | B    |       2
  3 | C    |       3

Eu gostaria de atualizá-lo para

 id | name | ordinal 
----+------+---------
  1 | A    |       3
  2 | B    |       2
  3 | C    |       1

Tocando nos registros o mínimo possível (ou seja, não reescreva todo o conjunto de registros, não inicie gatilhos desnecessários), qual é a abordagem geralmente aplicável para atualizar ordinalos valores de destino?

Uma atualização vanilla apenas me dá violações de restrição, mesmo que aconteça em uma única instrução.

E descartar e recriar a restrição exclusiva é uma concorrência cara e ruim.

Este parece ser um problema comum o suficiente para que deve haver uma boa maneira de fazer isso, que eu simplesmente não consigo pensar.

Meu entendimento é que uma atualização bloqueia uma tupla, marca-a como excluída e adiciona uma nova tupla.

Em outras palavras, update = delete + insert.

Ou então eu tinha acreditado. Mas parece que há algo fundamentalmente diferente sobre atualização de delete + insert no MVCC.

Configurar:

CREATE TABLE example (a int PRIMARY KEY, b int);
INSERT INTO example VALUES (1, 1);

Método 1: Atualizar

-- session A                          session B
BEGIN;
UPDATE example SET b = 2 WHERE a = 1;
                                      DELETE FROM example WHERE a = 1;
COMMIT;
-- now there are 0 rows in table example (1 row was deleted by session B)

Método 2: Excluir e inserir

-- session A                          session B
BEGIN;
DELETE FROM example WHERE a = 1;
INSERT INTO example VALUES (1, 2);
                                      DELETE FROM example WHERE a = 1;
COMMIT;
-- now there is 1 row in table example (0 rows deleted by session B)

Desta forma

UPDATE example SET b = 2 WHERE a = 1;

é diferente de

DELETE FROM example WHERE a = 1;
INSERT INTO example VALUES (1, 2);

Como devo entender a natureza da atualização do MVCC? A tupla tem algum tipo de "identidade" MVCC que é preservada durante a atualização? O que é isso?

No PostgreSQL, tenho usado sintaxe como

TABLE example1
UNION ALL
TABLE example2

que entendo ser equivalente a

SELECT * FROM example1
UNION ALL
SELECT * FROM example2

Mas um colega me fez perguntas sobre isso e não consigo encontrar nenhum documento do PostgreSQL sobre essa sintaxe. ("TABLE" não é uma frase de pesquisa útil.) Onde posso encontrar documentação sobre isso?

É padrão ANSI SQL?

EDIT: Atualmente, aparentemente, até confunde o realce de sintaxe do StackExchanges.