Início / dba / Perguntas / 278476
Accepted
Paul Draper
Asked: 2020-10-22 17:41:23 +0800 CST

O que é "especial" na atualização do PostgreSQL vs delete+insert

  • 772

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?

postgresql concurrency

1 respostas

  1. Best Answer

    Sim, há uma diferença entre UPDATEe DELETE+ INSERT.

    Vamos usar a pageinspectextensão para ver as tuplas e os cabeçalhos das tuplas.

    Se você quiser repetir meu experimento, terá que descartar e recriar a tabela no meio. Além disso, pode haver sinalizadores adicionais (bits de dica) se você selecionou as linhas antes de examiná-las.

    O significado de infomask2e infomaskpode ser encontrado em src/include/access/htup_details.h, veja as citações no final da resposta.

    Após o UPDATE:

    SELECT lp, t_xmin, t_xmax, t_ctid, t_infomask2, t_infomask, t_attrs
FROM heap_page_item_attrs(get_raw_page('example', 0), 'example');

 lp | t_xmin | t_xmax | t_ctid | t_infomask2 | t_infomask |            t_attrs            
----+--------+--------+--------+-------------+------------+-------------------------------
  1 | 380943 | 380944 | (0,2)  |       16386 |        256 | {"\\x01000000","\\x02000000"}
  2 | 380944 |      0 | (0,2)  |       32770 |      10240 | {"\\x01000000","\\x02000000"}
(2 rows)

    • A primeira tupla é a morta. Seu t_ctidfoi alterado para apontar para a versão atualizada.

      Este é um dos pontos-chave, então deixe-me expandir isso: o de uma tupla ctidé a combinação do número do bloco e o “ponteiro de linha” ( lpno resultado da consulta. t_ctidapontar para a nova versão de linha. Este é o link entre a tupla original e a versão atualizada.

      t_infomask2é 2 (o número de colunas) mais HEAP_HOT_UPDATED, então esta linha recebeu uma atualização HOT (havia espaço suficiente no bloco e não há índice). t_infomaské HEAP_XMIN_COMMITTED(um pouco de dica).

    • A segunda tupla é a nova versão.

      t_infomask2é 2 plus HEAP_ONLY_TUPLE, portanto, esta é uma “tupla somente de heap” que só pode ser acessada por meio da atualização ctidda versão antiga. t_infomaské HEAP_XMAX_INVALID(true, é 0) mais HEAP_UPDATED(esta é a versão atualizada).

    Depois do DELETE+ INSERT:

    SELECT lp, t_xmin, t_xmax, t_ctid, t_infomask2, t_infomask, t_attrs
FROM heap_page_item_attrs(get_raw_page('example', 0), 'example');

 lp | t_xmin | t_xmax | t_ctid | t_infomask2 | t_infomask |            t_attrs            
----+--------+--------+--------+-------------+------------+-------------------------------
  1 | 380958 | 380961 | (0,1)  |        8194 |        256 | {"\\x01000000","\\x02000000"}
  2 | 380961 |      0 | (0,2)  |           2 |       2048 | {"\\x01000000","\\x02000000"}
(2 rows)

    • Novamente, a primeira tupla é a morta.

      t_infomask2é 2 mais HEAP_KEYS_UPDATED(esta é uma tupla excluída ou atualizada) e t_infomaské HEAP_XMIN_COMMITTED(a tupla era válida antes de ser excluída).

    • A segunda tupla é a inserida:

      t_infomask2é 2 mais, e t_infomaské HEAP_XMAX_INVALID(é 0), então esta é uma nova tupla.

    Explicação da diferença observada:

    No READ COMMITTEDnível de isolamento, uma transação sempre vê a última versão confirmada de uma linha. O DELETEna sessão B tem que bloquear a linha e é bloqueado pelo UPDATEou DELETEna sessão A.

    A documentação explica o que acontece quando o bloqueio é liberado:

    UPDATE, DELETE, SELECT FOR UPDATEe SELECT FOR SHAREcomandos se comportam da mesma forma queSELECTem termos de busca de linhas de destino: eles só encontrarão linhas de destino que foram confirmadas na hora de início do comando. No entanto, essa linha de destino pode já ter sido atualizada (ou excluída ou bloqueada) por outra transação simultânea no momento em que for encontrada. Nesse caso, o suposto atualizador aguardará que a primeira transação de atualização seja confirmada ou revertida (se ainda estiver em andamento). Se o primeiro atualizador reverter, seus efeitos serão negados e o segundo atualizador poderá prosseguir com a atualização da linha originalmente encontrada. Se o primeiro atualizador confirmar, o segundo atualizador ignorará a linha se o primeiro atualizador a excluiu, caso contrário, ele tentará aplicar sua operação à versão atualizada da linha. A condição de pesquisa do comando (oWHEREcláusula) é reavaliada para ver se a versão atualizada da linha ainda corresponde à condição de pesquisa. Em caso afirmativo, o segundo atualizador prossegue com sua operação usando a versão atualizada da linha.

    No caso de UPDATEhá um link entre a versão de linha antiga e a nova, então o PostgreSQL bloqueia e exclui a nova versão de linha, enquanto no caso de DELETE+ INSERTnão há versão válida da linha após o bloqueio ter desaparecido e nada esta deletado.

    Portanto, embora em muitos aspectos UPDATEe DELETE+ INSERTsejam bastante semelhantes no PostgreSQL, eles não são os mesmos: no segundo caso, não há conexão entre a linha excluída e a inserida.

    Apêndice: o significado de infomaskeinfomask2

    t_infomask:

    /*
 * information stored in t_infomask:
 */
#define HEAP_HASNULL            0x0001  /* has null attribute(s) */
#define HEAP_HASVARWIDTH        0x0002  /* has variable-width attribute(s) */
#define HEAP_HASEXTERNAL        0x0004  /* has external stored attribute(s) */
#define HEAP_HASOID             0x0008  /* has an object-id field */
#define HEAP_XMAX_KEYSHR_LOCK   0x0010  /* xmax is a key-shared locker */
#define HEAP_COMBOCID           0x0020  /* t_cid is a combo cid */
#define HEAP_XMAX_EXCL_LOCK     0x0040  /* xmax is exclusive locker */
#define HEAP_XMAX_LOCK_ONLY     0x0080  /* xmax, if valid, is only a locker */

 /* xmax is a shared locker */
#define HEAP_XMAX_SHR_LOCK  (HEAP_XMAX_EXCL_LOCK | HEAP_XMAX_KEYSHR_LOCK)

#define HEAP_LOCK_MASK  (HEAP_XMAX_SHR_LOCK | HEAP_XMAX_EXCL_LOCK | \
                         HEAP_XMAX_KEYSHR_LOCK)
#define HEAP_XMIN_COMMITTED     0x0100  /* t_xmin committed */
#define HEAP_XMIN_INVALID       0x0200  /* t_xmin invalid/aborted */
#define HEAP_XMIN_FROZEN        (HEAP_XMIN_COMMITTED|HEAP_XMIN_INVALID)
#define HEAP_XMAX_COMMITTED     0x0400  /* t_xmax committed */
#define HEAP_XMAX_INVALID       0x0800  /* t_xmax invalid/aborted */
#define HEAP_XMAX_IS_MULTI      0x1000  /* t_xmax is a MultiXactId */
#define HEAP_UPDATED            0x2000  /* this is UPDATEd version of row */
#define HEAP_MOVED_OFF          0x4000  /* moved to another place by pre-9.0
                                         * VACUUM FULL; kept for binary
                                         * upgrade support */
#define HEAP_MOVED_IN           0x8000  /* moved from another place by pre-9.0
                                         * VACUUM FULL; kept for binary
                                         * upgrade support */
#define HEAP_MOVED (HEAP_MOVED_OFF | HEAP_MOVED_IN)

#define HEAP_XACT_MASK          0xFFF0  /* visibility-related bits */

    t_infomask2:

    /*
 * information stored in t_infomask2:
 */
#define HEAP_NATTS_MASK         0x07FF  /* 11 bits for number of attributes */
/* bits 0x1800 are available */
#define HEAP_KEYS_UPDATED       0x2000  /* tuple was updated and key cols
                                         * modified, or tuple deleted */
#define HEAP_HOT_UPDATED        0x4000  /* tuple was HOT-updated */
#define HEAP_ONLY_TUPLE         0x8000  /* this is heap-only tuple */

#define HEAP2_XACT_MASK         0xE000  /* visibility-related bits */
    • 15

relate perguntas