nicholaswmin's questions

Quando um usuário aborta sua solicitação no meio do processo, às vezes cancelo quaisquer instruções somente leitura que suportem qualquer operação somente leitura que ele estava tentando no momento - sigo esse padrão com moderação - reservado apenas para consultas caras que também ocorrem durante períodos de alto tráfego portanto, tendo o potencial de causar contenção.

No PG, cancelo consultas assim:

SELECT pg_cancel_backend(pid);

Quando faço isso, o PG obedece, mas registra isto: Error: canceling statement due to user request.

Entendo por que seu irmão pg_terminate_backendse classificaria como um erro; é uma última tentativa potencialmente perigosa que mata o processo à força.

Mas não entendo por que o cancelamento de uma consulta normal é tratado da mesma forma. Afinal, solicitei o cancelamento, então por que ele foi registrado com um nível de severidade tão alto?

Temos uma mesa onde armazenamos eventos. Esta é uma tabela somente de acréscimo com 4 bilhões de linhas/eventos nela. Nós nunca excluímos nem atualizamos as linhas nesta tabela, portanto, nunca temos dead_rowsnela.

O wraparound de ID de transação AFAIK é impedido por execuções frequentes de AUTOVACUUM .

No entanto, no meu entendimento, o AUTOVACUUM nunca é executado em tabelas somente gravação porque elas não têm linhas mortas, portanto, nunca excedem o autovacuum_threshold.

Como o wraparound de ID de transação seria evitado nesse caso?

Temos um sistema que recebe eventos de clientes e os armazena em um banco de dados.

Cada evento é salvo como um atomic INSERTe possui uma id_eventchave primária auto-incrementada.

Nossos clientes podem executar uma ação específica que faz com que 2 eventos sejam disparados em rápida sucessão:

• 1)name: 'board-added', boardId: 12344
• 2)name: 'board-switched', boardId: 12344

Ambos os eventos chegam ao nosso servidor na ordem correta.

No entanto, por algum motivo, continuamos encontrando alguns board-switchedeventos com um id_eventque precede seu board-addedevento correspondente.

Como você pode ver no conjunto de resultados abaixo, board-addedtem um valor maior id_eventque o board-switchedque está errado.

{name: "board-switched", boardId: 313994, id_event: 48041136} {name: "board-added", boardId: 313994, id_event: 48041137}

Minha pergunta é:

É possível que 2 INSERTeventos, executados sequencialmente, façam com que o 2º INSERTseja concluído antes do 1º INSERT?

• Temos uma única tabela onde armazenamos Events .
• A tabela tem um índice em sua chave primária

Assumindo que estamos apenas fazendo SELECTs ou s simples INSERTnessa tabela - o tempo de recuperação ou inserção ficaria visivelmente* mais lento à medida que mais e mais linhas fossem adicionadas?

Meu entendimento (muito grosseiro) é que um índice torna o tempo de pesquisa não linear (não-O(N)), portanto, pelo menos teoricamente, não será um problema - mas gostaria de confirmar isso.

Estamos trabalhando com o PostgreSQL 9.5.3 e em algum momento esperamos que essa tabela tenha bilhões de linhas.

*perceptível: leva < 1 segundo para recuperar 5.000 eventos agora, perceptível seria > 2 segundos