Dean MacGregor's questions

Eu tinha uma tabela da qual queria excluir muitas linhas, mas estava falhando devido a restrições de memória. Eu vi uma sugestão para "simplesmente" copiar todas as linhas que não quero excluir em uma nova tabela, descartar a tabela antiga e renomear a nova tabela para o nome da tabela antiga. Isso seria bom, exceto para outros objetos que dependem da tabela original. Pelo que posso dizer, isso significa que eu teria que descartar o cascade e recriar tudo o que depende da tabela original.

Existe uma maneira de script tudo o que depende da tabela original para que eu possa recriá-los facilmente no pgadmin ou no psql?

Como alternativa, existe uma maneira de ignorar a dependência por tempo suficiente para excluir a tabela antiga e renomear a nova tabela para o nome da tabela antiga?

Eu acredito que é assim que o pg_repack funciona, então deve haver uma maneira.

Então eu tenho o Ubuntu 14.04 com postgres 9.6 e eu queria instalar o pg_repack então eu fiz

sudo apt-get install pgxnclient`
sudo pgxn install pg_repack

mas recebi um erro (desculpe, esqueci o erro) e encontrei um site dizendo que preciso

sudo apt-get install postgresql-server-dev-all
sudo apt-get install postgresql-common

Eu suspeito que um ou ambos vieram como Postgresql 10 porque quando eu fiz

sudo pgxn install pg_repack

parece funcionar, exceto que está colocando os arquivos /usr/lib/postgresql/10/binquando ainda estou executando o servidor 9.6.

Posso apenas mover isso para /usr/lib/postgresql/9.6/binou há algo específico sobre isso para postgres10 que não funcionará se eu apenas movê-lo?

Em segundo lugar, como configuro pgxnpara usar 9.6 e não 10?

O site aqui está morto, então imagino que haja documentação por aí que não consigo obter.

Digamos que eu queira CLUSTERuma mesa. Não há como saber quanto tempo vai demorar, então eu apenas executo. Depois de algumas horas, preciso dos dados, então cancelo o CLUSTERcomando. O CLUSTERing funciona com tabelas/arquivos temporários de tal forma que, se eu cancelar antes de terminar, tudo isso é apagado e as horas de execução são desperdiçadas ou faz alterações "ao vivo" de modo que o cancelamento após algumas horas não seja um desperdício total de tempo?

Estou executando um pg_dump do meu banco de dados postgres 9.4 e, ocasionalmente, ocorrerá um erro se algum outro processo tiver um bloqueio exclusivo em uma tabela. Existe uma maneira de o pg_dump simplesmente ignorar essa tabela e prosseguir com o restante do banco de dados em vez de apenas parar em suas trilhas?

Eu tenho uma tabela com cerca de 100 milhões de linhas. Ele só obtém dados inseridos uma vez por dia, mas precisamos fazer selectmuito. Os selects são geralmente simples, mas às vezes precisam retornar centenas de milhares de linhas.

É único com base em três colunas node_id, pricedate, hourque são integer, timestamp, integer respectivamente. Era lento para a maioria das consultas, mas eu o agrupei em node_id, pricedatee isso corrigiu a lentidão da maioria das consultas. Essas consultas eram do tipo:

select * from mytable where node_id in (1,2,3,4)

Ainda ocasionalmente precisamos fazer consultas como:

select * from mytable where pricedate>='2016-05-01'

Estes ainda são lentos porque são agrupados node_idprimeiro. Já temos um índice pricedate. O problema é que os usuários geralmente precisam de dados suficientes para que o mecanismo de consulta lance o índice e use uma varredura de sequência. Depois de usar uma varredura sequencial, ele se beneficia muito de ter os dados agrupados da maneira como estão sendo consultados. Isso leva ao problema que tenho, onde algumas consultas se beneficiam de um agrupamento e outras consultas do outro:

Seria bom se houvesse uma maneira de ter duas cópias físicas da tabela em que uma cópia é agrupada de uma maneira e a outra é agrupada de outra, mas o acesso do usuário a ela aparece como se houvesse apenas 1 tabela e o mecanismo de banco de dados garantiria que eles está em sincronia. Obviamente, haveria penalidades de gravação ao fazer isso, mas isso é irrelevante para nosso uso.

Algo assim seria possível?

Acho que não existe uma maneira integrada de fazer o que descrevo. Para fazer isso de qualquer maneira, acho que criaria uma tabela chamada mytable_dupcom a mesma restrição de chave exclusiva, mas com o agrupamento alternativo e, em seguida, configuraria gatilhos para inserir nela sempre que o mestre fosse inserido/atualizado/excluído. Isso parece factível, mas a partir daqui, haveria uma maneira razoável de selectpartir da tabela duplicada que seria eficiente?

Estou executando o PostgreSQL 9.4 em casa e 9.5 no Google.

Eu tenho esta tabela:

CREATE TABLE spp.rtprices (
  "interval" timestamp without time zone NOT NULL,
  rtlmp numeric(12,6),
  rtmcc numeric(12,6),
  rtmcl numeric(12,6),
  node_id integer NOT NULL,
  CONSTRAINT rtprices_pkey PRIMARY KEY ("interval", node_id),
  CONSTRAINT rtprices_node_id_fkey FOREIGN KEY (node_id)
      REFERENCES spp.nodes (node_id) MATCH SIMPLE
      ON UPDATE RESTRICT ON DELETE RESTRICT
)

E mais um índice relevante:

CREATE INDEX rtprices_node_id_interval_idx ON spp.rtprices (node_id, "interval");

Contra isso, fiz esta opinião:

  CREATE OR REPLACE VIEW spp.rtprices_hourly AS 
  SELECT (rtprices."interval" - '00:05:00'::interval)::date::timestamp without time zone AS pricedate,
  date_part('hour'::text, date_trunc('hour'::text, rtprices."interval" - '00:05:00'::interval))::integer + 1 AS hour,
  rtprices.node_id,
  round(avg(rtprices.rtlmp), 2) AS rtlmp,
  round(avg(rtprices.rtmcc), 2) AS rtmcc,
  round(avg(rtprices.rtmcl), 2) AS rtmcl
  FROM spp.rtprices
  GROUP BY date_part('hour'::text, date_trunc('hour'::text, rtprices."interval" - '00:05:00'::interval))::integer + 1,
           rtprices.node_id,
           (rtprices."interval" - '00:05:00'::interval)::date::timestamp without time zone;

O objetivo é fornecer médias das colunas numéricas para cada hora (os timestamps têm dados a cada 5 minutos). O problema é que uma consulta de um único dia para um único node_idleva mais de 30 segundos para 24 registros.

explain analyze select * from spp.rtprices_hourly
where node_id=20 and pricedate='2015-02-02'

Retorna isso :

   "HashAggregate  (cost=1128767.71..1128773.79 rows=135 width=28) (actual time=31155.023..31155.065 rows=24 loops=1)"
"  Group Key: ((date_part('hour'::text, date_trunc('hour'::text, (rtprices."interval" - '00:05:00'::interval))))::integer + 1), rtprices.node_id, (((rtprices."interval" - '00:05:00'::interval))::date)::timestamp without time zone"
"  ->  Bitmap Heap Scan on rtprices  (cost=10629.42..1128732.91 rows=2320 width=28) (actual time=25071.410..31153.715 rows=288 loops=1)"
"        Recheck Cond: (node_id = 20)"
"        Rows Removed by Index Recheck: 7142233"
"        Filter: (((("interval" - '00:05:00'::interval))::date)::timestamp without time zone = '2015-02-02 00:00:00'::timestamp without time zone)"
"        Rows Removed by Filter: 124909"
"        Heap Blocks: exact=43076 lossy=82085"
"        ->  Bitmap Index Scan on rtprices_node_id_interval_idx  (cost=0.00..10628.84 rows=464036 width=0) (actual time=68.999..68.999 rows=125197 loops=1)"
"              Index Cond: (node_id = 20)"
"Planning time: 5.243 ms"
"Execution time: 31155.392 ms"

Esta manhã, meu banco de dados entrou em modo suspeito. Voltei ao backup completo da noite passada para colocá-lo online novamente. Examinei o log de erros e encontrei o último comando que parecia causar o modo suspeito MERGEem uma tabela específica. Corri DBCC CHECKTABLEem cima da mesa e voltei o seguinte

Msg 2511, Level 16, State 1, Line 1
Table error: Object ID 1253579504, index ID 7, partition ID 72057594230341632, alloc unit ID 72057594364887040 (type In-row data). Keys out of order on page (1:14254237), slots 184 and 185.
There are 366539002 rows in 3425599 pages for object "PJM_Prices".
CHECKTABLE found 0 allocation errors and 1 consistency errors in table 'PJM_Prices' (object ID 1253579504).
repair_rebuild is the minimum repair level for the errors found by DBCC CHECKTABLE (CaisoAnalyzer.dbo.PJM_Prices).
DBCC execution completed. If DBCC printed error messages, contact your system administrator.

dentroERRORLOG

Internal database snapshot has split point LSN = 001935ad:00001bf6:0001 and first LSN = 001935ad:00001bf5:0001

Existe possivelmente uma maneira de colocar apenas essa tabela no modo de usuário único ou algum outro truque em que não preciso entrar no modo de usuário único para todo o banco de dados?

Eu tenho um banco de dados que está perto de encher o disco rígido no qual ele vive. Eu gostaria de expandir o banco de dados para outro disco rígido para lidar com isso.

Vejo que há uma opção Arquivos nas propriedades do banco de dados no SSMS que eu poderia adicionar, mas realmente não quero adicionar arquivos sem saber o que vem a seguir. Preciso adicionar uma nova entrada aos grupos de arquivos e, em seguida, adicionar aos arquivos? O tipo PRIMARY deve ser usado apenas para o primeiro arquivo? Se não, qual é a diferença entre tornar um primário e outro secundário? Depois de adicionar um arquivo, o mecanismo de banco de dados decide automaticamente onde colocar os dados ou preciso entrar em minhas tabelas e especificar isso de alguma forma?

Desculpe se isso é uma duplicata. Eu ficaria surpreso se não fosse, mas não consegui encontrar outra pergunta que tivesse essas respostas.