All perguntas(dba)

Considere a seguinte consulta:

select distinct pnumber
from project
where pnumber in
(select pnumber
 from project, department d, employee e
 where e.dno=d.dnumber
 and
 d.mgr_snn=ssn 
 and 
 e.lname='employee1' and project.pnumber = 2 )
or
pnumber in
(select pno
 from works_on, employee
 where essn=ssn and lname='employee1' );

Eu queria testar usando índices de brin, então eliminei as restrições de chave primária em todas as minhas tabelas e adicionei os seguintes índices:

CREATE INDEX idx_brin_pnumber ON project USING brin(pnumber);
CREATE INDEX idx_brin_ssn ON project USING brin(ssn);
CREATE INDEX idx_brin_dnumber ON project USING brin(dnumber);
CREATE INDEX idx_brin_essn ON project USING brin(essn);

e anexarei o plano de consulta de saída abaixo

Eu costumava pensar que o motivo era devido ao seqScans necessário durante a junção, mas quando executo a mesma consulta sem nenhum indício e habilito o seqscan, ele faz isso com um custo muito menor. Então, qual é a razão para isso?

Tenho cerca de 60 GB de dados em um cluster Scylla simples e gostaria de migrá-los para Cassandra 4.1.5. Tirei um instantâneo do scylla com o comando

nodetool snapshot -t scylla-20240524 --table <table> <keystore>

Agora estou tentando importá-lo para o Cassandra executando

bin/sstableloader -d localhost -k <keystore> /mnt/scylla-20240524

Mas recebo a seguinte saída:

Established connection to initial hosts
Opening sstables and calculating sections to stream
Skipping file me-4332-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4333-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4334-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4335-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4400-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4401-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4402-big-Data.db: table <keystore>.scylla doesn't exist
Skipping file me-4403-big-Data.db: table <keystore>.scylla doesn't exist

Summary statistics: 
   Connections per host    : 1         
   Total files transferred : 0         
   Total bytes transferred : 0.000KiB  
   Total duration          : 3954 ms   
   Average transfer rate   : 0.000KiB/s
   Peak transfer rate      : 0.000KiB/s

Não consigo encontrar 'scylla' como tabela no esquema scylla... há algo que devo fazer para preparar o esquema cassandra? ou o que mais?

Estamos tendo alguns problemas que nos impedem de entrar em operação com uma nova plataforma de camada SQL 2016 Std Ed local para Azure SQL Managed Instance Business Critical, e gostaria de saber se alguém teve problemas semelhantes e teve conselhos para nós. Nossos problemas são:

1. O problema nº 1 é a compilação inicial excessiva do plano de consulta para consultas em pelo menos uma dúzia de procedimentos armazenados e outras consultas (40 segundos a 174 segundos... Já vi exemplos de até 725 segundos!). Isso está levando a tempos limite de aplicativos frequentes e aleatórios , já que a maioria está definida como padrão de 30 segundos. Para esclarecer, não se trata de recompilações excessivas, mas de um CompileTime muito alto no plano de consulta.

As consultas e informações em https://erikdarling.com/are-long-compile-times-bringing-you-down/ foram muito úteis para identificar essas consultas (li https://littlekendra.com/2024/ 03/05/long-compilers-who-time-out-not-in-query-store/ também). Também vemos alguns tempos limite de compilação: https://www.brentozar.com/blitzcache/compilation-timeout/ .

Estamos tentando ajustar essas consultas e reduzir sua complexidade, pois nos disseram que isso deveria reduzir o CompileTime. Também tentamos atualizar o nível AZ MI para Business Critical, adicionando vCores e ajustando configurações de instância e banco de dados por meses.

Estamos trabalhando em um caso Sev B com a Microsoft há várias semanas e recebemos algumas dicas, mas ainda sem resolução. O suporte de nível 3 recomendou garantir que as consultas de tempo limite de compilação não tenham planos forçados, porque forçar o plano permite que o SQL Optimizer gaste 3x a duração do normal para compilar, o que aumenta a probabilidade de tempo limite. A única coisa que estava forçando os planos é o ajuste automático, que se aplica ao MI apenas para a opção FORCE_LAST_GOOD_PLAN de acordo com https://learn.microsoft.com/en-us/sql/relational-databases/automatic-tuning/automatic-tuning?view= sql-server-ver16 e https://learn.microsoft.com/en-us/azure/azure-sql/database/automatic-tuning-overview?view=azuresql . Desativamos FORCE_LAST_GOOD_PLAN de acordo com a recomendação deles e isso ajudou alguns dos CompileTimes altos, mas não todos. Não estamos forçando planos com o guia de plano (USE PLAN N'<xml_plan>') ou forçando manualmente no Query Store. Eles recomendaram ajustar consultas para reduzir sua complexidade e executar um DUMP se desligar FORCE_LAST_GOOD_PLAN não funcionar. Espero agendar uma sessão de trabalho com a equipe de desempenho para solucionar esses problemas.

Atualização: durante nossa ligação em 28/05 com suporte de nível 3, percebemos que até mesmo algumas consultas triviais como SELECT COUNT(*) FROM Table estavam usando OptimizationLevel = FULL em vez de TRIVIAL. O suporte da Level 3 disse que não havia nenhuma configuração que pudéssemos alterar para afetar isso, mas mencionaria isso à equipe de produto.

2. Nosso trabalho de manutenção de partição que faz ALTER PARTITION SPLIT é executado por muito mais tempo (dias a semanas) no MI BusCrit em comparação com o mesmo código no SQL 2016 Std Ed. Ele também consome muito espaço extra usado no arquivo de dados (e log) durante o processamento, o que não acontece no SQL 2016, como um banco de dados de 52 GB que cresceu para 588 GB! enquanto o trabalho estava em execução. O inchaço (e o desempenho?) pode estar parcialmente relacionado à Recuperação Acelerada de Banco de Dados (ADR), uma vez que está no SQL 2019+ e AZ MI: Tamanho da tabela na Instância Gerenciada de SQL do Azure versus SQL Server Local (consulte também https://learn. microsoft.com/en-us/sql/relational-databases/accelerated-database-recovery-concepts?view=sql-server-ver16 ).

Estamos revisando o algoritmo que herdamos, pois parece não seguir as práticas recomendadas em https://learn.microsoft.com/en-us/sql/t-sql/statements/alter-partition-function-transact-sql?view =sql-server-ver16 "Sempre mantenha partições vazias em ambas as extremidades do intervalo de partições. Mantenha as partições em ambas as extremidades para garantir que a divisão da partição e a mesclagem da partição não incorram em nenhuma movimentação de dados. A divisão da partição ocorre no início e a mesclagem da partição ocorre no final. Evite dividir ou mesclar partições preenchidas A divisão ou mesclagem de partições preenchidas pode ser ineficiente porque a divisão ou mesclagem pode causar até quatro vezes mais geração de log e também pode causar problemas graves. travamento." Mas estamos intrigados por que o mesmo código é executado por muito mais tempo e incha excessivamente o arquivo de dados no MI, quando isso não aconteceu no SQL 2016 Std Ed.

Outra recomendação que consideramos é migrar para VMs do Azure com SQL, mas isso adicionará meses ao lançamento da nossa nova plataforma para configurar, testar e operacionalizar esse ambiente, pois não temos nenhuma VM do Azure no momento. Também teremos que operacionalizar patches, backups, etc.

Eu aprecio sua ajuda! Mike

Desinstalou o antigo módulo PS e substituiu-o pelo novo SQLServer, mas agora a terceira etapa do sistema job syspolicy_purge_history, que é uma etapa do Powershell, falha com a seguinte mensagem:

As informações de erro retornadas pelo PowerShell são: 'O módulo especificado 'SQLPS' com versão '15.0' não foi carregado porque nenhum arquivo de módulo válido foi encontrado em nenhum diretório de módulo. '<

Se eu adicionar #NOSQLPSno topo do script, a mensagem de erro muda ligeiramente, indicando que não é possível localizar o novo módulo:

'Não é possível encontrar a unidade. Não existe uma unidade com o nome 'SQLSERVER'. '

Módulos SQL atuais:

Diretórios do módulo:

Como posso fazer funcionar novamente?

Obrigado

Eu tenho uma tabela particionada nativamente por data. As partições abrangem 1 mês. Tenho outra tabela muito grande (19 GB) da qual desejo copiar os dados para a tabela particionada. Eu usei pg_partmanesse processo, porém o partman.partition_data_procprocedimento levou 12 horas para mover 9 GB de dados para 60 novas partições. Para referência, estou usando o Postgres 15 no Amazon RDS (M5 Large).

Eu tentei usar partman.partition_data_procpara mover os dados. Faça as seguintes perguntas, para um caso mais concreto:

-- NOTE: Both tables have more columns, this is a minimal example
CREATE TABLE IF NOT EXISTS table1(
    id bigint not null,
    date timestamp not null,
    col_a integer,
    col_b double precision,
    col_c varchar(255)
);

-- insert some data into "table" at this step
-- for example using something like this: 
-- insert into table (
--      "id",
--  "date",
--  "col_a" ,
--  "col_b",
--  "col_c"
-- )
-- select
--  i,
--  get_random_date_between(start:='10 years', end:='1 day'),
--  random()::int,
--  (random()* 100)::numeric(10, 2),
--  'Some Text'
-- from
--  generate_series(1,300000000) s(i);

CREATE TABLE IF NOT EXISTS partitioned_table(
    id bigint not null,
    date timestamp not null,
    col_a integer,
    col_b double precision,
    col_c varchar(255)
) PARTITION BY RANGE (date);

-- NOTE: you will need to have pg_partman extension installed
-- https://github.com/pgpartman/pg_partman
SELECT partman.create_parent(
        p_parent_table => 'public.partitioned_table',
        p_control => 'date',
        p_interval => '1 month'
    );

          
-- This operation takes a very long time
call partman.partition_data_proc(
    p_parent_table := 'public.partitioned_table',
    p_interval := '1 month',
    p_source_table := 'public.table1'
);

Também tentei mover os dados com a funcionalidade de exportação/importação de dados do DBeaver (era mais lento e inseria dados na partição padrão). Existe uma maneira mais rápida de fazer isso? Gostaria de poder transferir os dados em menos de 8 horas e não precisar trocar a instância RDS por algo mais caro.

Eu tenho uma tabela grande (cerca de 2,2 bilhões de linhas), a estrutura da tabela é básica:

    Column    |  Type   | Collation | Nullable |             Default              | Storage | Compression | Stats target | Description
--------------+---------+-----------+----------+----------------------------------+---------+-------------+--------------+-------------
 Id           | bigint  |           | not null | generated by default as identity | plain   |             |              |
 ItemId       | uuid    |           | not null |                                  | plain   |             |              |
 StartUtc     | integer |           | not null |                                  | plain   |             |              |
 EndUtc       | integer |           | not null |                                  | plain   |             |              |
 Price        | integer |           | not null |                                  | plain   |             |              |
Indexes:
    "PK_PriceHistoryEntry" PRIMARY KEY, btree ("Id")
    "IX_PriceHistoryEntry_ItemId" btree ("ItemId") CLUSTER

Todas as consultas são feitas na ItemIdcoluna, no formato:

SELECT "ItemId", "StartUtc", "EndUtc", "Price" FROM "PriceHistoryEntry" WHERE "ItemId" IN (...array of guids)

A tabela não é particionada porque cada consulta selecionada precisaria alcançar todas as partições, as consultas nunca são feitas apenas em determinados intervalos de datas, sempre no histórico completo.

O método de inserção geral é uma vez por semana, 10-20 milhões de entradas de histórico de preços são inseridas, a tabela é reagrupada no ItemIdíndice e, em seguida, as seleções têm alto desempenho para nossos propósitos (~ 100 ms para a pesquisa média que fazemos, que é de aproximadamente 250-400 GUIDs nos INcritérios que retornam aproximadamente 50 mil linhas).

No desenvolvimento testei isso com até 5 bilhões de linhas e até 1000 GUIDs nos INcritérios, sempre foi rápido. Ele estava funcionando perfeitamente há mais de um ano, mas hoje o PostgreSQL parou de usar o índice quando INcontém mais de 400 GUIDs e não consigo entender o porquê, plano de índice para 400 GUIDs:

Index Scan using "IX_PriceHistoryEntry_ItemId" on public."PriceHistoryEntry"  (cost=0.58..32570020.41 rows=23433784 width=28) (actual time=11.355..110.863 rows=160503 loops=1)
   Output: "ItemId", "StartUtc", "EndUtc", "Price"
   Index Cond: ("PriceHistoryEntry"."ItemId" = ANY ('{ac5aa227-8787-46fc-b34d-47017edc7d1f,*cut 398 guids*,16923b11-30b7-4311-bc54-3b2b1da314d0}'::uuid[]))
   Buffers: shared hit=828 read=2550
   I/O Timings: shared read=79.971
 Planning Time: 0.314 ms
 JIT:
   Functions: 4
   Options: Inlining true, Optimization true, Expressions true, Deforming true
   Timing: Generation 0.234 ms, Inlining 0.064 ms, Optimization 6.114 ms, Emission 4.823 ms, Total 11.235 ms
 Execution Time: 115.573 ms
(11 rows)

Time: 116.586 ms

mas se você usar GUIDs 401:

 Gather  (cost=1000.99..32292650.29 rows=23734217 width=28) (actual time=232.393..55599.947 rows=161872 loops=1)
   Output: "ItemId", "StartUtc", "EndUtc", "Price"
   Workers Planned: 2
   Workers Launched: 2
   Buffers: shared hit=7543 read=17088587
   I/O Timings: shared read=48381.022
   ->  Parallel Seq Scan on public."PriceHistoryEntry"  (cost=0.99..29918228.59 rows=9889257 width=28) (actual time=227.890..51672.274 rows=53957 loops=3)
         Output: "ItemId", "StartUtc", "EndUtc", "Price"
         Filter: ("PriceHistoryEntry"."ItemId" = ANY ('{bff9de7e-7f35-4f5d-88c5-2c342806d69b,*cut 399 guids*,618ce691-c8f0-46b2-8fd1-96a404bdda71}'::uuid[]))
         Rows Removed by Filter: 683791228
         Buffers: shared hit=7543 read=17088587
         I/O Timings: shared read=48381.022
         Worker 0:  actual time=329.642..50237.693 rows=54262 loops=1
           JIT:
             Functions: 4
             Options: Inlining true, Optimization true, Expressions true, Deforming true
             Timing: Generation 0.238 ms, Inlining 45.205 ms, Optimization 4.210 ms, Emission 3.867 ms, Total 53.520 ms
           Buffers: shared hit=2368 read=5516111
           I/O Timings: shared read=15615.749
         Worker 1:  actual time=122.393..49195.649 rows=52913 loops=1
           JIT:
             Functions: 4
             Options: Inlining true, Optimization true, Expressions true, Deforming true
             Timing: Generation 0.240 ms, Inlining 45.364 ms, Optimization 4.256 ms, Emission 3.936 ms, Total 53.796 ms
           Buffers: shared hit=2447 read=5377318
           I/O Timings: shared read=15380.362
 Planning Time: 0.396 ms
 JIT:
   Functions: 12
   Options: Inlining true, Optimization true, Expressions true, Deforming true
   Timing: Generation 0.767 ms, Inlining 90.645 ms, Optimization 16.254 ms, Emission 13.825 ms, Total 121.492 ms
 Execution Time: 55604.845 ms
(32 rows)

Time: 55606.114 ms (00:55.606)

Como eu disse, ao desenvolver isso, testei-o extensivamente com até 5 bilhões de linhas e mais de 1.000 GUIDs nos INcritérios, o que é significativamente mais do que o que está atualmente no banco de dados e nunca encontrei esse problema.

Eu tentei:

• Reagrupando a mesa
• ReindexaçãoIX_PriceHistoryEntry_ItemId
• VACUUM ANALYZEna mesa
• VACUUM FULLna mesa
• Reconstruindo a tabela inteira compg_repack

Ainda se recusa a usar o índice agora. Alguma ideia do que aconteceu, como consertar e como garantir que isso nunca aconteça novamente?

Se eu desabilitar seq scan( set enable_seqscan = off;) ele usará o índice corretamente e retornará os resultados em 100ms... em vez dos 55 segundos que leva quando o PostgreSQL usa o plano que considera melhor. Desabilitar o seqscan parece não ser recomendado, se eu diminuí-lo, random_page_costele usará o índice para consultas um pouco maiores, mas para consultas particularmente grandes, INele ainda usará uma varredura de sequência. Preciso garantir que ele nunca use uma varredura sequencial, pois nunca será mais rápido para esta tabela.

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?

Estou interessado em experimentar esta solução: https://dba.stackexchange.com/a/44893/71052 , também referenciado aqui: https://dba.stackexchange.com/a/206151/71052

O problema que enfrento é o seguinte:

• mysqldump exporta explicitamente o mecanismo de armazenamento para cada tabela:

    CREATE TABLE `footable` (  
      `foocolumn1` bigint(20) unsigned NOT NULL AUTO_INCREMENT,  
      `foocolumn2` bigint(20) unsigned NOT NULL DEFAULT '0',  
      ...  
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_520_ci;  

• quando estou restaurando o dump, o BlackHole é definido como mecanismo padrão, mas a tabela é criada conforme explicitamente declarado no dump - o que na verdade parece bastante normal.

-> Existe alguma forma de forçar a substituição do motor? (Quero dizer, como opção de restauração, editar o dump não é solução aqui)
-> Suponho que a solução seja a postagem citada:

Inicie um servidor Mysql dedicado com o mecanismo padrão blackhole ( e talvez o único )

Como posso iniciar uma instância do mysqld com Blackhole como o único mecanismo disponível? Eu vi muitos documentos sobre compilar com ou sem este ou aquele mecanismo, mas ainda não descobri como iniciá- lo sem innodb, myisam etc.

Quando o SQL Server cria estatísticas de amostra , como a porcentagem de amostragem é calculada?

Por exemplo, atualizando estatísticas na coluna PostId da tabela dbo.Votes no banco de dados Stack Overflow 2013:

UPDATE STATISTICS dbo.Votes
(
    _WA_Sys_00000002_0AD2A005
) 
WITH MAXDOP = 1;

O SQL Server cria uma instrução interna:

SELECT 
    StatMan
    (
        [SC0], 
        [SB0000]
    ) 
    FROM 
    (
        SELECT TOP 100 PERCENT 
            [SC0], 
            step_direction([SC0]) over (order by NULL) AS [SB0000]  
        FROM 
        (
            SELECT [PostId] AS [SC0] 
            FROM [dbo].[Votes] 
                TABLESAMPLE SYSTEM (9.234204e-01 PERCENT) 
                WITH (READUNCOMMITTED) 
        ) AS _MS_UPDSTATS_TBL_HELPER 
        ORDER BY 
            [SC0], 
            [SB0000] 
    ) AS _MS_UPDSTATS_TBL  
OPTION (MAXDOP 1)

De onde vem 9.234204e-01 PERCENT?

Tenho uma visão bastante simples que estou tentando indexar.

CREATE OR ALTER  VIEW [schema].[IndexedView]
WITH SCHEMABINDING AS
SELECT
    SUM(ISNULL([Quantity], 0)) as [Quantity],
    [Address],
    [Asset],
    [schema].GetThirdAddressPart([Address]) AS [PortfolioId],
    COUNT_BIG(*) AS [Count]
FROM
    [schema].[table]
WHERE (
    [Address] LIKE ('%:thing')
        OR [Address] LIKE ('%:thing2')
        OR [Address] LIKE ('%:thing3')
    )
GROUP BY [Address], [Asset], [schema].GetThirdAddressPart([Address])

Com o índice como

CREATE UNIQUE CLUSTERED INDEX [IDX_Index] ON [schema].[IndexedView]
(
    [Asset] ASC,
    [Address] ASC
)

A função ( GetThirdAddressPart) funciona da seguinte maneira

CREATE FUNCTION [schema].[GetThirdAddressPart] (@inputString varchar(30))
RETURNS varchar(30) WITH SCHEMABINDING
AS
BEGIN
    DECLARE @firstColonPos INT = CHARINDEX(':', @inputString);
    DECLARE @secondColonPos INT = CHARINDEX(':', @inputString, @firstColonPos + 1);
    DECLARE @thirdColonPos INT = CHARINDEX(':', @inputString, @secondColonPos + 1);

    RETURN SUBSTRING(
            @inputString,
            @secondColonPos + 1,
            CASE
                WHEN @thirdColonPos = 0 THEN LEN(@inputString)
                ELSE @thirdColonPos - @secondColonPos - 1
                END
           );

Executar o seguinte na função acima parece confirmar que a função deve funcionar bem

SELECT ObjectPropertyEx(Object_Id('schema.GetThirdAddressPart'), N'IsDeterministic') AS deterministic, 
        ObjectPropertyEx(Object_Id('schema.GetThirdAddressPart'), N'IsPrecise') AS precise, 
        ObjectPropertyEx(Object_Id('schema.GetThirdAddressPart'), N'IsSystemVerified') AS verified, 
        ObjectPropertyEx(Object_Id('schema.GetThirdAddressPart'), N'UserDataAccess') AS UserDataAccess,
        ObjectPropertyEx(Object_Id('schema.GetThirdAddressPart'), N'SystemDataAccess') AS SystemDataAccess;

Dá-me...

Eu verifiquei e isso atende aos requisitos para que uma UDF seja usada.

Se eu executar isso localmente no SQL Server executando através do Docker ( 2022:latest), recebo o seguinte erro

Msg 8668, Level 16, State 0, Line 34 Cannot create the clustered index 'IDX_Index' on view 'services-import.schema.IndexedView' because the select list of the view contains an expression on result of aggregate function or grouping column. Consider removing expression on result of aggregate function or grouping column from select list.

O que é estranho é que funciona se eu executá-lo no Banco de Dados SQL do Azure, o índice é criado sem problemas. Mesmos níveis de compatibilidade em ambos os bancos de dados.

O problema local é com o UDF, se eu comentar isso me permitirá indexá-lo.

1. Existe algum motivo para a diferença de comportamento do SQL Server em execução por meio do Docker versus o Banco de Dados SQL do Azure? A documentação não parece sugerir que deveria haver.
2. Tem alguma maneira de resolver isso? Sei que poderia adicionar a função como uma coluna computada à tabela original, só estava tentando evitá-la.

Versões SQL:

Local:
Microsoft SQL Server 2022 (RTM-CU12) (KB5033663) - 16.0.4115.5 (X64)   Mar  4 2024 08:56:10   Copyright (C) 2022 Microsoft Corporation  Developer Edition (64-bit) on Linux (Ubuntu 22.04.4 LTS) <X64>

Azure:
Microsoft SQL Azure (RTM) - 12.0.2000.8   Apr 19 2024 18:03:25   Copyright (C) 2022 Microsoft Corporation