All perguntas(dba)

É assim que minha mesa está:

    CREATE TABLE [dbo].[ClosedTaskCustomFields](
    [ClosedTaskId] [uniqueidentifier] NOT NULL,
    [CustomFieldId] [uniqueidentifier] NOT NULL,
    [Value] [nvarchar](450) NULL
    ... 
 CONSTRAINT [PK_ClosedTaskCustomFields] PRIMARY KEY CLUSTERED 
(
    [ClosedTaskId] ASC,
    [CustomFieldId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

E também tenho esse índice para ingressar na tabela ClosedTask:

CREATE NONCLUSTERED INDEX [IX_ClosedTaskCustomFields_ClosedTaskId] ON [dbo].[ClosedTaskCustomFields]
(
    [ClosedTaskId] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
GO

Mas não consigo entender por que essa consulta lê toda a tabela ClosedTaskCustomFields para ingressar no ClosedTask se eu tiver índice.

      select count(1) from ClosedTaskCustomFields ctcf
      join ClosedTask c on c.id = ctcf.ClosedTaskId
      where c.State = 'Rejected'
-- Result count is 50k.

plano: https://www.brentozar.com/pastetheplan/?id=SJ9Y4xFEp

Tenho um documento de tabela com aproximadamente 2,5 milhões de linhas e mais de 100 colunas. Forneço usado apenas em colunas de consulta:

CREATE TABLE document
(
  id serial PRIMARY KEY,
  organizationid INTEGER,
  status_1 TEXT NOT NULL,
  status_2 INTEGER DEFAULT 0 NOT NULL
);

CREATE INDEX ON document (organizationid);
CREATE INDEX ON document (status_1);
CREATE INDEX ON document (status_2);

Precisa otimizar a próxima consulta:

SELECT *
FROM document
WHERE status_1 = '42' AND status_2 = 0 AND organizationid = 42 
ORDER BY id
LIMIT 25;

Essa consulta funciona muito bem para outras organizações, mas a organização 42 não possui documentos com esse filtro (ou tem menos de 20 de tempos em tempos) e produz um plano de consulta incorreto e uma consulta lenta. O problema está nas distribuições de valores na tabela. A porcentagem de documentos com status_1 = '42' é 95%, status_2 = 0 é 10% e Organizationid = 42 é 2%. Portanto, o DB espera que haja cerca de 4.750 documentos para este filtro e faça a varredura do índice usando documnet_pkey e verifique a tabela completa sem encontrar nenhum documento. Demora vários minutos. Mas se eu mudar de organização para outra, que tenha muitos documentos, a consulta demorará menos de um segundo. E se eu mudar o filtro para organização com pequena quantidade de documentos - o banco de dados apenas usa o índice por ID da organização e depois classifica os documentos resultantes. Demora menos de 50 ms.

Como posso acelerar a consulta da organização 42? Ou o que preciso pesquisar para isso?

Eu uso PostgreSQL 12

auto-aspiração e análise ativadas, e executei a análise novamente antes dos testes. Já aumentei GEQO_EFFORT para 10 (máximo), DEFAULT_STATISTICS_TARGET para 1000 (mais impacto de valor em outras consultas), estatística criada:

CREATE STATISTICS custom_1 ON organizationid, status_1, status_2 FROM document;

criou índice específico:

CREATE INDEX ON document ((status_1 = '42' AND status_2 = 0 AND organizationid = 42));

e execute novamente a análise após todas as alterações. Mas isso não ajuda. Eu verifiquei pg_stats e pg_stats_ext, ele contém estatísticas corretas conforme esperado. Para a estatística criada, ela possui no valor mais comum outra combinação dessas colunas e não possui essa combinação, portanto é possível assumir aquela combinação onde é incomum. Para índice na expressão, a estatística diz que existem apenas valores falsos no índice.

Este é um problema muito comum, enfrentado por praticamente todos os DBA que têm responsabilidades tanto com as equipes de aplicativos quanto de BI. Considere o seguinte:

1. Você tem dois servidores T-SQL , Produção e Relatórios.
2. Todos os dias, às 6h, você deseja copiar novos dados da Produção para o Relatório. Pode haver filtros ou algum outro ETL feito neste processo.
3. Você não deseja copiar mais dados do que o necessário, então, idealmente, você deseja algum MERGEtipo.

Quais são as soluções idiomáticas para este problema?

Em minha própria pesquisa, descobri:

• Servidores vinculados - Eles são muito lentos ao fazer upserts e tendem a enviar toda a tabela pela rede quando são necessárias apenas algumas linhas.
• SSIS - Dolorosamente não portável, muito antigo e força você a passar por obstáculos extras, como colocar tabelas de teste em ambos os servidores.

Espero que haja algo melhor.

Recebi a tarefa de atualizar um cluster Cassandra baseado no Ubuntu - sem experiência anterior com Cassandra.

Tentei vasculhar a documentação , mas não consegui encontrar nenhuma instrução sobre como fazer atualizações de maneira compatível.

Felizmente, tenho um cluster de teste que atualiza perfeitamente, apenas garantindo que o apt aponte para o repositório correto e faça isso apt upgrade- mas talvez isso seja apenas porque o banco de dados não está sob nenhuma carga específica.

Os nós devem ser isolados antes da atualização ou algo semelhante? Ou é seguro confiar que ele fará o que quer?

Deveria, por exemplo, nodetool upgradesstablesser executado manualmente após uma atualização de 4.0 para 4.1?

Existe documentação sobre este tópico que não consegui localizar?

Consegui encontrar este recurso e é muito mais envolvente do que apt upgradeconsidero ter sido totalmente bem-sucedido.

Por que, quando estou SAVE TRAN SavePointno local (A), recebo esses erros na terceira instância de cair no CATCH e além...

"Msg 6401, Nível 16, Estado 1... Não é possível reverter o SavePoint. Nenhuma transação ou ponto de salvamento com esse nome foi encontrado."

...mas não recebo esses erros quando SAVE TRAN SavePoint;estou no local (B)?

Só posso imaginar que tenha algo a ver com o contexto do loop do cursor, mas não entendo por quê.

-- Premable stuff, opening cursor, etc. here...

BEGIN TRAN

SAVE TRAN SavePoint;  -- (A)

WHILE @@FETCH_STATUS = 0
BEGIN;

  -- SAVE TRAN SavePoint;  -- (B)

  BEGIN TRY

    -- UPDATE statement here which may fail

    SAVE TRAN SavePoint;

  END TRY
  BEGIN CATCH

    ROLLBACK TRAN SavePoint;

  END CATCH;

  FETCH NEXT FROM Cursor INTO @X, @Y, @Z;

END;

-- CLOSE & DEALLOCATE stuff here

IF @DryRun = 1
  ROLLBACK TRAN;
ELSE
  COMMIT TRAN;

Esta é uma pequena amostra do que tenho em meu banco de dados.

CREATE TEMPORARY TABLE temp_ledger(
    book_entry INT,
    credit DOUBLE(24, 8),
    debit DOUBLE(24, 8)
);

INSERT INTO
    temp_ledger(book_entry, credit, debit)
VALUES
    (1, 17.54500000, 0.00000000),
    (1, 0.00000000, 14.50000000),
    (1, 0.00000000, 3.04500000),
    (2, 0.00000000, 99.85500000),
    (2, 95.10000000, 0.00000000),
    (2, 4.75500000, 0.00000000);

SELECT
    book_entry,
    SUM(ROUND(debit, 2)) as sum_of_rounded_debit,
    SUM(ROUND(credit, 2)) as sum_of_rounded_credit,
    ROUND(SUM(debit), 2) as round_of_summed_debit,
    ROUND(SUM(credit), 2) as round_of_summed_credit,
    SUM(debit) as summed_debit,
    SUM(credit) as summed_credit
FROM
    temp_ledger
GROUP BY
    book_entry;

DROP TEMPORARY TABLE temp_ledger;

Saída

temp_ledger

Não entendo por que sum_of_rounded_debita entrada do livro 1 é 17,54 :

• 14,50 arredondado deve ser 14,50
• 3,045 arredondado deve ser 3,05

E round_of_summed_creditpara o lançamento contábil 2 é 99,85 se summed_credit for 99,855 , por que o arredondamento me dá 99,85 e não 99,86

Eu entendo que às vezes os decimais podem ser complicados, mas round_of_summed_creditem particular me pergunto "O quê?".

Isso surgiu ao tentar encontrar erros na tabela llx_accounting_bookkeeping de Dolibarr, uma vez que a soma da rodada fornece algumas linhas como incompatíveis entre crédito e débito, enquanto a soma da rodada fornece um conjunto diferente de linhas.

Usando MariaDB 10.5.8

Eu tenho um banco de dados com vários esquemas que possuem as mesmas tabelas e visualizações e quero criar um procedimento que crie uma visualização a partir de uma das visualizações do esquema.

CREATE OR REPLACE FUNCTION create_summary_view(
    created_view character varying,
    common_view character varying,
    schema_1 character varying,        
    schema_2 character varying,        
    schema_3 character varying,
    ...
    schema_x character varying,        
)

create_viewé a visualização que será criada, common_viewé a visualização idêntica em todos os esquemas e schema_xé a lista de esquemas cujos common_views estão sendo unidos created_view.

O pl/pgsql possui uma sintaxe para indicar um número variável de parâmetros? created_view, common_viewe pelo menos one schema_xé necessário?

Estou considerando uma alternativa para passar uma string separada por vírgula ou espaço dos esquemas e usá-la regexp_split_to_arraypara separá-la, mas seria bom saber que argumentos de comprimento variável são possíveis.

No MySQL 8.0.33, estou enfrentando uma forma de contenção (reproduzida em múltiplas instâncias) que não é explicada pela documentação.

Como exemplo:

1. Eu inicializo uma instância
2. em um cliente de console, invoco a SELECT COUNT(*)em uma tabela relativamente grande (alguns GBs de registros + índices totais)
3. em um cliente separado, invoco a ANALYZE TABLEem uma tabela menor e separada

o resultado é que a segunda instrução ( ANALYZE TABLE) fica suspensa por um tempo, bloqueada em um System Lockestado; este é um exemplo de saída:

+----+--------+------+-------+---------+------+-------------+---------------------------------+
| Id | User   | Host | db    | Command | Time | State       | Info                            |
+----+--------+------+-------+---------+------+-------------+---------------------------------+
| 18 | _user_ | _ip_ | _db_  | Query   |   72 | executing   | SELECT COUNT(*) FROM _table_1_  |
| 32 | _user_ | _ip_ | _db_  | Query   |   45 | System lock | ANALYZE TABLE _table_2_         |
+----+--------+------+-------+---------+------+-------------+---------------------------------+

Com base na documentação ( aqui e aqui ), o MySQL parece estar bloqueando (pelo menos) ambas as tabelas enquanto pagina os registros das primeiras ( SELECT).

O que exatamente está fazendo com que o MySQL bloqueie várias tabelas enquanto executa um SELECT em uma?

Estou tentando melhorar esta consulta. Quando executo isso como usuário, ele é executado em aproximadamente 1 minuto, mas durante o carregamento do ETL pode levar até 40 minutos. Não deve haver problemas de bloqueio porque essas tabelas não são referenciadas em nenhum outro lugar.

Com base no plano de consulta, que direção devo seguir?

Posso melhorar minha indexação. Ele usa correspondências de hash e mesclagens podem melhorar isso com a indexação.

Preciso de uma abordagem que não seja uma série de LEFT JOINs?

Os nomes das colunas e tabelas foram ofuscados:

https://www.brentozar.com/pastetheplan/?id=rJc7-rHV6

Estou tentando entender o processo de como o percona faz backup a quente. pelo que entendi, eles usam o mecanismo de recuperação de falhas innodb e executam as etapas a seguir.

1. armazenar/lembrar iniciar LSN a partir de logs de redo
2. copiar arquivos de dados
3. execute LOCK BINLOG FOR BACKUP: para bloquear todas as operações que possam alterar a posição do log binário
4. copiando os arquivos de log REDO e buscando as coordenadas binárias do log
5. o xtrabackup concluído desbloqueará o log binário e as tabelas.

Quero entender qual é a função do LSN nos redo logs. Não podemos verificar diretamente a posição do log binário na etapa 1?

E o LSN final, ele não é usado em nenhum lugar do processo?