All perguntas(dba)

Eu tenho uma tabela PostgreSQL 13 bastante grande que preciso adicionar uma nova TEXTcoluna e com esta nova coluna gostaria de adicionar uma GENERATED ALWAYScoluna com a seguinte definição:

ALTER TABLE my_table
ADD COLUMN text_col TEXT,
ADD COLUMN text_col__tsvector GENERATED ALWAYS AS (to_tsvector('pt_unaccent', "text_col")) STORED;

No entanto, quando executo o DDL acima, demora muito para ser concluído. Pelo que entendi, é porque é text_col__tsvectornecessário executar a expressão para todas as linhas da tabela, mesmo que text_colseja NULL.

Minha dúvida é: sabendo que a text_colcoluna sempre começará como NULL(nenhum valor padrão está definido) existe uma maneira de fazer o postgres pular a parte da primeira geração na criação do text_col__tsvector? Ou alterar a parte da expressão ( to_tsvector('pt_unaccent', "text_col")) da GENERATED ALWAYScoluna para ignorar NULLvalores?

Estou trabalhando em um pequeno projeto para monitorar métricas de atividades e execução de procedimentos armazenados do usuário. Periodicamente (a cada 10 minutos ou mais), estou tirando instantâneos do DMV sys.dm_exec_procedure_stats e, em seguida, INNER JOIN instantâneos sucessivos nas colunas de procedimento database_id, object_id , plan_handle e plan cached_time para calcular deltas de métricas de execução. O que me confunde é que esses deltas às vezes são negativos , já que em alguns casos raros os valores das métricas exec do snapshot posterior são inferiores aos valores do snapshot anterior do mesmo objeto. Como isso é possível?

Estou fazendo essa coisa de coleta/processamento de dados em diversas instâncias e diversas versões do SQL Server e, até o momento, esse comportamento estranho ocorre apenas no SQL Server 2008 R2.

Há um exemplo na imagem abaixo. Os instantâneos destacados têm valores de métricas exec mais baixos (total_worker_time, execução_count etc.) em comparação com o instantâneo anterior do mesmo objeto, o que é estranho, uma vez que ambos os instantâneos têm o mesmo database_id, object_id, plan_handle e tempo de cache do plano.

Observação: os instantâneos mostrados na imagem abaixo não foram processados ​​de forma alguma pelo meu script, eles são o resultado do antigo - SELECT "colunas desejadas" FROM sys.dm_exec_procedure_stats .

Só para esclarecer um pouco mais o que estou fazendo, este é o algoritmo que estou usando para tirar snapshots e calcular deltas:

1. Tire um instantâneo (S0) de sys.dm_exec_procedure_stats ( SELECT "colunas desejadas" FROM sys.dm_exec_procedure_stats )

2. Espere um pouco (digamos - 10 minutos);

3. Tire outro instantâneo (S1) de sys.dm_exec_procedure_stats ( SELECT "colunas desejadas" FROM sys.dm_exec_procedure_stats )

4. Classifique os snapshots S0 e S1 por carimbo de data/hora, faça INNER JOIN nas colunas database_id, object_id, plan_handle e plan_cached_time e calcule os deltas das métricas de execução.

O script que resulta deste algoritmo é bastante simples. O que me incomoda é que, quando despejo os instantâneos S0 e S1 na tela do SSMS, às vezes (no SQL Server 2008 R2) obtenho resultados mostrados na imagem acima, onde o instantâneo (S1) tem valores de métricas de execução mais baixos em comparação com o instantâneo S0, mesmo embora ambos compartilhem o mesmo database_id, object_id, plan_handle e plan_cache_time, e o snapshot S1 tenha um valor DATETIME last_execution_time mais alto .

Não sei... Talvez eu esteja fazendo algo errado aqui, mas se alguém estiver construindo um script de monitoramento de procedimento do usuário com base em dados agregados do DMV sys.dm_exec_procedure_stats, talvez deva ter cuidado, pois pode acabar com negativo deltas no SQL Server 2008 R2.

Este é um script que estou usando para verificar deltas negativos/inválidos. Por favor, deixe-me saber se a lógica está errada.
Testei nas versões do SQL Server 2008 R2, 2012, 2016, 2017 e 2019, e deltas negativos foram encontrados apenas no SQL Server 2008 R2.

SET NOCOUNT ON

-- Create a table to hold sys.dm_exec_procedure_stats snapshots
IF OBJECT_ID('tempdb.dbo.#SNAPSHOTS') IS NULL
BEGIN 
    CREATE TABLE #SNAPSHOTS (
        timestamp DATETIME2(0), 
        database_id INT, 
        object_id INT, 
        plan_handle VARBINARY(64), 
        plan_cached_time DATETIME, 
        last_execution_time DATETIME, 
        execution_count BIGINT, 
        total_elapsed_time BIGINT, 
        total_worker_time BIGINT, 
        total_logical_reads BIGINT
    )
END

DECLARE @timestamp DATETIME2(0), @last_execution_time DATETIME, @iteration INT = 0, @negatives INT = 0, @rows INT

-- Loop indefinitely
WHILE 1 = 1
BEGIN 
    
    -- Get last execution time from the snapshot table
    SELECT @last_execution_time = MAX(last_execution_time), 
            @timestamp = GETDATE()
    FROM #SNAPSHOTS
    
    IF @last_execution_time IS NULL
        SET @last_execution_time = GETDATE() - 30
    
    -- Take snapshot from sys.dm_exec_procedure_stats DMV of all procs. that were executed after the last snapshot collection time
    INSERT INTO #SNAPSHOTS
    SELECT @timestamp, database_id, object_id, plan_handle, cached_time, last_execution_time, execution_count, total_worker_time, total_elapsed_time, total_logical_reads
    FROM sys.dm_exec_procedure_stats
    WHERE last_execution_time > @last_execution_time
    
    SET @rows = @@ROWCOUNT
    
    -- Check for negative/invalid deltas
    ;WITH c AS (
        SELECT ROW_NUMBER()OVER(PARTITION BY database_id, object_id, plan_handle, plan_cached_time ORDER BY timestamp) row, *
        FROM #SNAPSHOTS
    )
    SELECT @negatives = COUNT(*)
    FROM c s0 
        INNER JOIN c s1 ON s0.database_id = s1.database_id AND s0.object_id = s1.object_id AND s0.plan_handle = s1.plan_handle AND s0.plan_cached_time = s1.plan_cached_time AND s0.row = s1.row - 1
    WHERE s1.execution_count - s0.execution_count < 0 
        OR s1.total_elapsed_time - s0.total_elapsed_time < 0
        OR s1.total_logical_reads - s0.total_logical_reads < 0
        OR s1.total_worker_time - s0.total_worker_time < 0
    
    SET @iteration += 1
    RAISERROR(N'Iteration: %d. Rows added: %d. Negative/Invalid deltas: %d', 10, 10, @iteration, @rows, @negatives) WITH NOWAIT

    WAITFOR DELAY '00:01:00' -- Wait a bit before taking another snapshot

END

Sou bastante novo no Postgres, tendo passado anos com MySQL/MariaDB. Eu tenho um banco de dados Postgres 14.9 para desenvolvimento com dois esquemas nele. Quando perco a energia, ambos os esquemas ainda existem no banco de dados, mas os dados de um dos esquemas desaparecem. O registro diz:

[1199] LOG:  database system was not properly shut down; automatic recovery in progress
[1199] LOG:  redo starts at 0/3094A290
[1199] LOG:  invalid record length at 0/3094A378: wanted 24, got 0
[1199] LOG:  redo done at 0/3094A340 system usage: CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s
[1050] LOG:  database system is ready to accept connections

Como se trata de desenvolvimento, perder esses dados não é grande coisa; Só continuo importando um dump, mas gostaria de saber por que isso está acontecendo e o que posso fazer para evitar, principalmente quando levo esse sistema para produção. Não alterei nenhuma configuração no Postgres ou no sistema operacional em relação ao cache de disco. Estou usando o Ubuntu 22.04 em uma VM e o host é o Windows 10 em um SSD.

Além disso, existe uma maneira de recuperar os dados sem importar meu despejo? Fiz algumas pesquisas que me levaram a tentar pg_resetxlog, pg_resetwalmas ambos disseram command not found.

Gostaria de corromper uma página de qualquer tabela do banco de dados AdventureWorks . Como fazer isso?

Gostaria de testar a restauração no nível da página e também colocar um banco de dados suspeito on-line novamente usando dbcc checkdb

Digamos que eu tenha duas transações A e B. A transação A começa primeiro. então a transação B é iniciada, insere alguns dados e confirma. Portanto, da transação A (ainda não confirmada), posso ver que os dados foram confirmados pela transação B. Como a transação A começa antes da transação B, seu XID seria menor que o XID da transação B. Pelo que entendi, a transação A só pode ver linhas que são modificados ou inseridos por transações cujo XID é menor que a transação A.

No exemplo acima (nível de isolamento de leitura confirmada), o XID da transação atual é 741, por que ele pode ver os dados que foram confirmados pela transação cujo XID é 742?

Desculpe, acho que meu exemplo não foi claro o suficiente. Iniciei duas transações A e B simultaneamente, deixei a transação B atualizar e inserir alguns dados, e a transação A pode ver esses dados após a confirmação da transação B. Então, eu me pergunto como as regras do MVCC funcionam no nível de isolamento de leitura confirmada.

Abaixo, o cenário de duas sessões tentando atualizar a mesma linha foi fornecido por Paul White.

Cenário 1:

1. A sessão 1 obtém um Ubloqueio na linha da tabela base durante a leitura.
2. Blocos da sessão 2, aguardando aquisição Una mesma linha da tabela base.
3. A sessão 1 define o valor como 10 e confirma.
4. A sessão 2 adquire seu Ubloqueio e não encontra nada para fazer, pois Value != 0 agora.

Resultado: o valor é definido como 10.

Com base em Paul, a sessão 2 já localizou a linha que precisa ser atualizada, mas foi bloqueada. Quando o bloqueio acabar e a sessão 2 obtiver o bloqueio U, será necessário verificar a condição novamente? Estou entendendo certo? Para mim é meio estranho. A sessão localizou esta linha porque avaliou o filtro que leva à identificação desta linha. Por que é necessário verificar a condição novamente antes da atualização real?

Às vezes, observamos esperas muito altas por HADR_SYNC_COMMIT e, após algum trabalho de diagnóstico com iperf3 e similares, achamos que pode haver um problema de largura de banda da rede.

No entanto, não somos uma equipe central de SQL, fazemos principalmente trabalhos de ajuste de banco de dados, então eu só queria tentar esclarecer algo para o qual não consigo obter uma resposta definitiva no Google.

Temos dois servidores (AL e BE) e existem várias instâncias em cada um. Para uns é primário, para outros é secundário.

Sabemos que o sql usa uma única conexão para sincronização e foi assim que fizemos os testes do iperf3. Às vezes, a largura de banda parecia cair para zero ou perto disso.

O que não temos certeza é em que nível isso é aplicado. É no nível da instância para que cada instância tenha sua própria conexão de sincronização? Ou se houver mais de um grupo de disponibilidade, cada um deles terá sua própria conexão?

Espero que esteja claro. Ainda estamos aprendendo sobre essas coisas.

Obrigado

Dados de amostra

Dados esperados

Preciso anexar negociações sob um pedido em um registro, consegui fazer isso usando string_agg, agora preciso dividir os pedidos com valor máximo de 10. Ou seja, a quantidade para o pedido único não deve ultrapassar 10, preciso combinar negócios sob um único pedido, tanto quanto possível, pois são desejáveis ​​menos pedidos alterados.

Por exemplo: posso combinar o tradeid 11 e 12, o total acumulado é 9, mas quando combino o tradeid 13 ele se torna 12 (excede 10), então isso precisa estar em uma ordem separada.

Pretendo classificar as negociações para poder agrupar por orderid e classificar para obter o resultado. Usando o SQL Server 2016.

Script para criar a tabela de amostra.

create table #order
(
orderid varchar(100),
tradeid varchar(100),
quantity  int
)

insert into #order (orderid, tradeid, quantity)
values 
('a',    'a1',    5),
('a',    'a2',    4),
('a',    'a3',    3),
('a',    'a4',    12),
('b',    'b1',    9),
('b',    'b2',    8),
('b',    'b3',    7)

Segundo exemplo

INSERT INTO @Test 
    (OrderID, TradeID, Qty)
VALUES ('a', 11, 5)
    , ('a', 12, 4)
    , ('a', 13, 3)
    , ('a', 14, 5)
    , ('a', 15, 1)
    , ('b', 21, 9)
    , ('b', 22, 8)
    , ('b', 23, 7)

resultado esperado

Na realidade, o máximo seria cerca de 1.000 pedidos em 10 negociações por pedido. Uma boa solução aproximada deve ser suficiente.

Olá, estou usando esta consulta que me fornece os resultados mostrados na imagem:

SELECT "t_stamp", "Total_Parts"
FROM myTable
WHERE "MachineName" = 'Main01'
AND "Quality" is not NULL
AND t_stamp >= '2023-08-10 16:30:00' AND t_stamp <= '2023-08-14 00:30:00'
ORDER BY 1 ASC

Eu me pergunto como posso obter apenas a contagem de cada hora... Por exemplo: eu sei que teria que somar os valores da coluna Total_Parts (na caixa vermelha), mas apenas para a hora 17, e depois os da coluna caixa roxa para a hora 18, e para a caixa verde para a hora 19. Conforme tabela a seguir:

Eu estava olhando este link , mas ainda não consegui descobrir. Qualquer ajuda seria muito apreciada. Obrigado.

Eu criei duas tabelas, uma é OrdersLatest e outra é OrdersMarch . Quero mudar os dados da tabela particionada para a tabela intermediária ( OrdersMarch ) no mesmo grupo de arquivos e vice-versa.

Estava funcionando bem para desligar, mas problema ao ligar. Meu caso SWITCH IN não funciona

Ele mostra o erro abaixo, que indica uma incompatibilidade de restrição entre a tabela de origem e de destino ( OrdersMarch ). Não tenho certeza do que devo alterar para resolver esse erro.

Eu verifiquei a partição esquerda e direita, mas o problema é o mesmo. Defino restrições na tabela intermediária ( OrdersMarch ) na coluna particionada também, mas o erro é o mesmo. Qualquer um pode resolver esse problema, onde está o problema exato?

A instrução ALTER TABLE SWITCH falhou. Verifique restrições ou função de partição da tabela de origem 'TEST.dbo.OrdersMarch' permite valores que não são permitidos por restrições de verificação ou função de partição na tabela de destino 'TEST.dbo.OrdersLatest'.

função de partição

CREATE PARTITION FUNCTION OrdersLatestPartitionFunction (datetime)  
    AS RANGE RIGHT FOR VALUES (
        '20180101', 
        '20190101',
        '20200101'
    );
GO

Esquema de Partição

CREATE PARTITION SCHEME OrdersLatestPartitionScheme
    AS PARTITION OrdersLatestPartitionFunction  
    TO (
        OrdersLatestFg1,
        OrdersLatestFg2,
        OrdersLatestFg3,
        OrdersLatestFg4
        );  
GO

Criar a tabela

CREATE TABLE OrdersLatest (
    OrderDate date NOT NULL,
    OrderId int IDENTITY NOT NULL,
    OrderDesc varchar(255) NOT NULL,
    CONSTRAINT PKOrdersLatest PRIMARY KEY CLUSTERED(OrderDate, OrderId)
    )  
    ON OrdersLatestPartitionScheme(OrderDate);  
GO

Alternar tabela de destino

CREATE TABLE OrdersMarch (
    OrderDate date NOT NULL,
    OrderId int IDENTITY NOT NULL,
    OrderDesc varchar(255) NOT NULL,
    CONSTRAINT PKOrdersMarch PRIMARY KEY CLUSTERED(OrderDate, OrderId)
    )
    ON OrdersLatestFg3;
GO

Inserção de dados

INSERT INTO OrdersLatest(OrderDate, OrderDesc) VALUES
    ('20190302', 'Cat food'),
    ('20190315', 'Water bowl'),
    ('20190318', 'Saddle for camel'),
    ('20190321', 'Dog biscuits'),
    ('20190328', 'Bigfoot shoes');
GO

Saída Após a Inserção

+-------------+-----------------+--------+
| Partition   | Filegroup       | Rows   |
|-------------+-----------------+--------|
| 1           | OrdersLatestFg1 | 0      |
| 2           | OrdersLatestFg2 | 0      |
| 3           | OrdersLatestFg3 | 5      |
| 4           | OrdersLatestFg4 | 0      |
+-------------+-----------------+--------+

Troque

ALTER TABLE OrdersLatest SWITCH PARTITION 3 TO OrdersMarch;

Saída Após Interruptor

+-------------+-----------------+--------+
| Partition   | Filegroup       | Rows   |
|-------------+-----------------+--------|
| 1           | OrdersLatestFg1 | 0      |
| 2           | OrdersLatestFg2 | 0      |
| 3           | OrdersLatestFg3 | 0      |
| 4           | OrdersLatestFg4 | 0      |
+-------------+-----------------+--------+

Alternar em

ALTER TABLE OrdersMarch SWITCH TO OrdersLatest PARTITION 3; 

A instrução ALTER TABLE SWITCH falhou. Verifique restrições ou função de partição da tabela de origem 'TEST.dbo.OrdersMarch' permite valores que não são permitidos por restrições de verificação ou função de partição na tabela de destino 'TEST.dbo.OrdersLatest'.