All perguntas(dba)

test=# create table r (id serial primary key, x int, y int);
CREATE TABLE
test=# insert into r (x, y) select random() * 1000, random() * 1000 from generate_series(0, 1000000);
INSERT 0 1000001
test=# 
test=# create index r_x_idx on r using btree (x);
CREATE INDEX
test=# cluster r using r_x_idx ;
CLUSTER
test=# select * from r limit 5;
  id  | x |  y  
------+---+-----
   79 | 0 | 556
 5997 | 0 | 774
 6104 | 0 |  75
 6937 | 0 | 818
 7859 | 0 | 598
(5 rows)

test=# select * from r limit 5 offset 10000;
   id   | x  |  y  
--------+----+-----
 483314 | 10 | 842
 484136 | 10 | 741
 484568 | 10 | 729
 488499 | 10 | 311
 489022 | 10 | 613
(5 rows)

test=# select * from r limit 5;
   id   | x |  y  
--------+---+-----
 330361 | 9 | 614
 330928 | 9 |  48
 331658 | 9 | 712
 332175 | 9 | 448
 332818 | 9 | 920
(5 rows)

Conforme mostrado acima, criei a tabela r, depois criei um índice b+tree na coluna x, e então agrupei a tabela usando esse índice. Como esperado, quando executei select * from r limit 5;obtive registros com o menor xvalor, porque a ordem física dos registros agora é baseada na xcoluna (mais precisamente, com base no índice b+tree na coluna x). Mas depois de executar select * from r limit 5 offset 10000;, a ordem dos registros é alterada, sem nenhuma inserção. Alguém pode explicar esse comportamento?

Para tabelas com índices btree de cobertura, as atualizações de tuplas somente de heap (HOT) são possíveis quando colunas de índice não-chave são atualizadas?

Digamos que eu tenha uma tabela "usuários" com este índice:

CREATE INDEX users_email_index ON users(email) INCLUDE(name)

E o fator de preenchimento da tabela é 60; ocorrerá uma atualização HOT quando nameela for atualizada?

De acordo com a documentação :

postmaster é o servidor de banco de dados multiusuário do PostgreSQL. Para que um aplicativo cliente acesse um banco de dados, ele se conecta (por uma rede ou localmente) a um postmaster em execução. O postmaster então inicia um processo de servidor separado ("postgres") para manipular a conexão. O postmaster também gerencia a comunicação entre os processos do servidor.

Não consigo entender completamente o que significa multiusuário e não encontrei nenhuma explicação. Alguém pode me explicar qual é o trabalho do postmaster? Isso é algo como um balanceador de carga para vários servidores postgres?

PostgreSQL - 13.15. Tenho uma tabela com 7 TB de tamanho. Há um índice -

CREATE INDEX mytable_cmp_ts ON mytable USING btree (campaign_id, created_at);

Não posso tentar explain analyse para a consulta a seguir porque pode levar muito tempo. Um EXPLAIN diz que o índice será usado. Isso é possível, considerando que created_at é a segunda coluna no índice?

   explain select min(created_at) from mytable;
                                                                QUERY PLAN                                                                 
-------------------------------------------------------------------------------------------------------------------------------------------
 Finalize Aggregate  (cost=244894227.70..244894227.71 rows=1 width=8)
   ->  Gather  (cost=244894227.48..244894227.69 rows=2 width=8)
         Workers Planned: 2
         ->  Partial Aggregate  (cost=244893227.48..244893227.49 rows=1 width=8)
               ->  Parallel Index Only Scan using mytable_cmp_ts on mytable  (cost=0.71..238551221.08 rows=2536802560 width=8)

• Mais de 300 mil vídeos
• Mais de 10 milhões de marcadores apontando para intervalos de tempo em vídeos

{
  "markerCategory": "something",
  "markerDesc": "something-more-specific",
  "frameIn": 120001,
  "frameOut": 140002
},
{
  "markerCategory": "something-else",
  "markerDesc": "something-else-more-specific",
  "frameIn": 130001,
  "frameOut": 135002
}

Alguma sugestão de qual banco de dados/índice de pesquisa teria melhor desempenho
ao pesquisar algo neste sentido:

Vídeos com eventos de category A AND category B em intervalos de tempo sobrepostos,
classificados por quantidade de tempo coberto

Atualmente, os vídeos são exportados de algum banco de dados relacional proprietário e armazenados em uma instância do Apache SOLR para pesquisa.

• Existe um nome específico para esse tipo de consulta ("consultas de intervalo invertido" ou algo assim...)?
• Alguma sugestão de qual tecnologia teria melhor desempenho para esses tipos de consultas?
  Eu estava pensando talvez em Elasticsearch?

Tenho um procedimento armazenado que contém uma única consulta select. Dentro da consulta, há alguns aliases que representam uma fórmula ou expressão.

É possível extrair o cálculo/fórmula/expressão para quem tem um?

No exemplo abaixo, estou tentando extrair algo como:

"s * 2" para ScoreTimesTwo

"s * 5" para ScoreTimesFive

"CASE..." (a declaração completa do caso) para ConditionalScore

Além disso, escrevi a consulta de forma a cobrir o fato de que campos/expressões podem ser atribuídos a aliases de diferentes maneiras (equals ou "AS") e as expressões podem estar na mesma linha ou em várias linhas.

Tentei usar sys.dm_exec_describe_first_result_set, mas parece que ele só identifica colunas de origem referenciadas diretamente (ou seja, quando elas não fazem parte de uma fórmula) e nunca a fórmula em si, que é o que preciso.

/* Drop and create the test score table */
DROP TABLE IF EXISTS Test_ScoreTable
GO

CREATE TABLE Test_ScoreTable(s INT)
GO

/* Insert sample data into the score table */
INSERT INTO Test_ScoreTable(s)
SELECT t.s
FROM   (VALUES (100), (50), (10)) t(s)
GO

/* Drop and create test score stored procedure */
DROP PROCEDURE IF EXISTS Test_ScoreStoredProcedure
GO

CREATE PROCEDURE Test_ScoreStoredProcedure
AS

SELECT Score = t.s,
       ScoreTimesTwo = t.s * 2,
       t.s * 5 AS ScoreTimesFive,
       ConditionalScore = CASE t.s
                            WHEN 100 THEN 'Good'
                            WHEN 10 THEN 'Bad'
                            ELSE 'Eh...'
                          END
FROM   Test_ScoreTable t

GO

/* Attempt to extract the calculations and expressions */
SELECT s.[name], s.source_column, s.is_computed_column, *
FROM   sys.dm_exec_describe_first_result_set('Test_ScoreStoredProcedure', NULL, 1) s

Estou tentando fazer a soma de 9 cálculos individuais, conforme listado abaixo, onde os resultados usam uma cascata de 1 a 9. Uma determinada conta nunca terá um valor para cada um dos 9 cálculos diferentes, no entanto, ela pode ter um valor em mais de um dos buckets calculados e, portanto, só queremos renderizar valores na ordem da cascata (1 a 9). Por exemplo, se uma determinada conta tivesse um valor para o primeiro (--1-) bucket calculado e o último (--9-) bucket calculado, então eu só gostaria de trazer o primeiro (--1-) valor calculado.

SELECT AccountNbr, 
SUM(CurrSofrOn) AS CurrSofrOn,
SUM(CurrTlpNonStableBase) AS CurrTlpNonStableBase,
SUM(CurrTlpStableBase) AS CurrTlpStableBase,
SUM(CurrBeta) AS CurrBeta, SUM(CurrFtp) AS CurrFtp,
SUM(CurrBase) AS CurrBase, SUM(CurrStabilityAdj) AS CurrStabilityAdj,
SUM(CurrTlpAdjAge) AS CurrTlpAdjAge, SUM(CurrModeled) AS CurrModeled

FROM
(
    SELECT 
    COALESCE(l.AcctNbr_2, l.AcctNbr_1) AS AccountNbr,

    --1-
    COALESCE(l.CurrAvgBook * l.SofrOnRate_2,0) AS CurrSofrOn,   
    --2-
    COALESCE(l.CurrAvgBook * l.MovingAvgBaseRt_2,0) AS CurrBase,
    --3-
    COALESCE(l.CurrAvgBook * l.TlpNonStableBase_2,0) AS CurrTlpNonStableBase,
    --4-
    COALESCE(l.CurrAvgBook * l.TlpStableBase_2,0) AS CurrTlpStableBase,
    --5-
    COALESCE(l.CurrAvgBook * l.Beta_2,0) AS CurrBeta,
    --6-
    COALESCE(l.CurrAvgBook * l.StableAdjBal_2,0) AS CurrStabilityAdj,
    --7-
    COALESCE(l.CurrAvgBook * l.FtpRate_2,0) AS CurrFtp,
    --8-
    COALESCE(l.CurrAvgBook * l.TlpAdjAge_2,0) AS CurrTlpAdjAge,
    --9-
    COALESCE(l.CurrAvgBook * l.FtpRateModel_2,0) AS CurrModeled
FROM
(  
    SELECT 
    n1.AcctNbr AS AcctNbr_1, n2.AcctNbr AS AcctNbr_2,
    n1.TotalBookValueEoM AS PrevCurrBook,n2.TotalBookValueEoM AS CurrBook, n1.TotalBookValueAvg AS PrevAvgBook, n2.TotalBookValueAvg AS CurrAvgBook, 
    n1.FtpRate_Model AS FtpRateModel_1, n2.FtpRate_Model AS FtpRateModel_2, n1.Stable_Base AS StableBase_1, n2.Stable_Base AS StableBase_2, 
    n1.SofrOnRate AS SofrOnRate_1, n2.SofrOnRate AS SofrOnRate_2, n1.StableAdjustment_Balance AS StableAdjBal_1,n2.StableAdjustment_Balance AS StableAdjBal_2,
    n1.FtpRate_Model_Floored AS FtpRateModelFloored_1, n2.FtpRate_Model_Floored AS FtpRateModelFloored_2, n1.TlpAdjustment_Age AS TlpAdjAge_1,
    n2.TlpAdjustment_Age AS TlpAdjAge_2, n1.MovingAverageBaseRate AS MovingAvgBaseRt_1, n2.MovingAverageBaseRate AS MovingAvgBaseRt_2, 
    n1.FtpRate_Final AS FtpRate_1, n2.FtpRate_Final AS FtpRate_2, n1.Beta AS Beta_1, n2.Beta AS Beta_2, n1.TlpTermInMonths_NonStable AS TlpTermInMnthsNS_1,
    n2.TlpTermInMonths_NonStable AS TlpTermInMnthsNS_2, n1.BaseRateIndex AS BaseRateIndex_1, n2.BaseRateIndex AS BaseRateIndex_2, 
    n1.TLP_Stable_Base AS TlpStableBase_1, n2.TLP_Stable_Base AS TlpStableBase_2, n1.TLP_NonStable_Base AS TlpNonStableBase_1, n2.TLP_NonStable_Base AS TlpNonStableBase_2
        FROM
        (
            SELECT DISTINCT *  
            FROM dbo.NonMaturityDepositResults n
            WHERE n.TapeDate = 2024-11-30
        ) n1
        FULL JOIN
        (
            SELECT DISTINCT *
            FROM dbo.NonMaturityDepositResults n
            WHERE n.TapeDate = '2024-10-31'
        ) n2 
        ON n2.account_key = n1.account_key
        and n2.Channel = n1.Channel
        and n2.DepositType = n1.DepositType 
    ) l
) a
GROUP BY  a.DepositChannel,a.DepositType

Eu instalei o Windows Server e habilitei o modo FIPS por meio da política de segurança local

Após a reinicialização, a tentativa de avaliar o MD5 do PowerShell falha - como esperado

Eu instalei o sql server 2022 e tentei calcular o hash MD5 que passa

Eu esperaria que o comando sql falhasse no cálculo MD5. Minhas perguntas são:

• por que o SQL ainda consegue calcular hash MD5?
• como posso provar que o servidor SQL está realmente sendo executado no modo FIPS?

desde já, obrigado

Normalmente não faço perguntas, mas estou quase no meu limite e prevejo que vou ter dificuldades com isso por um tempo. Para os revisores de perguntas, não encontrei nenhuma pergunta referente às versões do Mongo com as quais estou tendo problemas, nem meu erro específico para o nó arbiter.

Resumo:

O árbitro está falhando em uma atualização da v6 para a v7 por causa de um inválido featureCompabilityVersionque li e que ele não deveria se importar ou usar.

Estou esquecendo de algo óbvio relacionado à configuração/atualização do nó do árbitro?

Versão longa:

Estou usando o Docker Compose para gerenciar um conjunto de réplicas de bancos de dados Mongo consistindo de 1 primário, 1 secundário e 1 árbitro. Todos eles usam a docker.io/bitnami/mongodbimagem e têm volumes para persistir quaisquer dados que precisem gravar. Minha tarefa é atualizar suas imagens de v5 para v7 usando as instruções do Mongo .

A atualização da v5 para a v6 foi tranquila, pois a v6 é compatível com versões anteriores e só exigiu a atualização da versão da imagem. Para atualizar para a v7, entrei no banco de dados de administração do nó primário e executei db.adminCommand( { setFeatureCompatibilityVersion: "6.0" } )seguido por db.adminCommand( { getParameter: 1, featureCompatibilityVersion: 1})para confirmar que a alteração foi feita.

Atualizei as versões de imagem no arquivo compose de v6 para v7 e reiniciei. Os nós primário/secundário estão bem, mas o arbiter emite esse erro antes de desligar,

PROBLEMA DE ATUALIZAÇÃO: Foi encontrado um documento featureCompatibilityVersion inválido (ERRO: Location4926900: Documento featureCompatibilityVersion inválido em admin.system.version: { _id: "featureCompatibilityVersion", versão: "5.0" }. Consulte https://docs.mongodb.com/master/release-notes/6.0-compatibility/#feature-compatibility . :: causado por :: Valor de versão de compatibilidade de recurso inválido '5.0'; esperado '6.0' ou '6.3' ou '7.0'. Consulte https://docs.mongodb.com/master/release-notes/6.0-compatibility/#feature-compatibility. ). Se o featureCompatibilityVersion atual for inferior a 6.0, consulte a documentação sobre atualização em https://docs.mongodb.com/master/release-notes/6.0/#upgrade-procedures .

Agora eu li que o árbitro não deve conter dados e que o árbitro ignora o FCV em favor da compatibilidade com versões anteriores relatada pelos binários, que se for verdade, deve ser v6, não v5 como o erro declara. Eu tentei autenticar no árbitro para definir o FCV lá, mas eu recebo command setFeatureCompatibilityVersion requires authentication.

Estou esquecendo de algo óbvio relacionado à configuração/atualização do nó do árbitro?

Temos um PostgreSQL (com extensão TimescaleDB) em execução em um servidor Ubuntu, cuja carga tem aumentado constantemente ao longo do ano.

Gostaríamos de manter a carga sob controle. Para CPU, ou carga, gostaríamos de identificar consultas que estão causando o aumento na carga, pois algumas das consultas são provavelmente desnecessárias; a frequência pode ser diminuída, e assim por diante.

Qual seria a melhor maneira de mapear consultas e/ou aplicações PostgreSQL para uso de CPU? Especificamente, como essa não é uma consulta única, deve haver algum tipo de coleta de estatísticas por um período maior de tempo.

Atualmente, estamos usando o Datadog para monitorar o PostgreSQL e o servidor, mas ficaremos felizes em considerar quaisquer opções.