All perguntas(dba)

Quero atualizar todas as colunas nomeadas com sufixo '[]' na tabela geochemse tiverem zeros (0) com NULL.

Esta consulta retorna todos os nomes de colunas relevantes:

select c.COLUMN_NAME 
  from information_schema.COLUMNS as c 
 where c.TABLE_NAME = 'geochem' 
   and c.COLUMN_NAME like '%\[%\]'

Exemplo de resultados:

Em seguida, atualize os valores nessas colunas, por exemplo, colunaSiO2[%{wt}]

UPDATE geochem
SET "SiO2[%{wt}]" = NULL
WHERE "SiO2[%{wt}]" = 0;

Como posso combinar essas consultas para atualizar todas as colunas retornadas pelo primeiro trimestre, em vez de atualizar coluna por coluna manualmente?

Tenho o equívoco de que SELECT * FROM sys.dm_os_performance_counters WHERE counter_name LIKE 'Stolen Server Memory%';mostra quanta memória o sistema operacional está roubando do SQL Server. A verdade, segundo a documentação , é

Especifica a quantidade de memória que o servidor está usando para outras finalidades além das páginas do banco de dados.

que considero significar "a quantidade de memória usada pelo SQL Server (ou seja, não pelo sistema operacional) para qualquer coisa diferente do buffer pool".

Com isso em mente, faz sentido verificar sys.dm_os_performance_countersse já estou verificando SELECT * FROM sys.dm_os_memory_clerks ORDER BY pages_kb DESC? Dado que o buffer pool está sempre no topo da lista (seu servidor estará condenado se não estiver), determinar quanta memória não está sendo usada por ele deve ser uma simples questão de aritmética.

Suspeito que estou errado sobre isso porque esses dois números não correspondem no meu servidor. No entanto, não sei como descobrir o porquê.

-- Total stolen memory.
SELECT top (1) cntr_value
FROM sys.dm_os_performance_counters
WHERE counter_name LIKE 'Stolen Server Memory%'
ORDER BY cntr_value desc;

-- Total memory not in buffer pool.
-- Should be the same as the above but is always less on my machine.
SELECT SUM(pages_kb)
FROM sys.dm_os_memory_clerks
WHERE [Type] <> 'MEMORYCLERK_SQLBUFFERPOOL';

Tenho três tabelas event, person e event_person_map

evento:

id integer PRIMARY KEY
event_name text
event_date date

pessoa:

id integer PRIMARY KEY
full_name text
email_address text

mapa_pessoa_evento:

id integer PRIMARY KEY
person_id integer [referencing person.id]
event_id integer [referencing event.id]

Como posso estruturar minha consulta para obter uma saída que liste informações sobre o evento e a lista de participantes?

Um exemplo da saída seria algo assim:

event_id| event_name | event_date |participants|
--------+------------+------------+------------+
 1      |   event1   |  1.1.2024  | json list  | 
 2      |   event2   |  1.2.2024  | json list  | 
 3      |   event3   |  1.3.2024  | json list  | 
 4      |   event4   |  1.4.2024  | json list  |

A estrutura da lista json de participantes deve ser semelhante a esta:

[
   {
      "id":1,
      "full_name":"John Doe",
      "email_address":"[email protected]"
   },
   {
      "id":2,
      "full_name":"Jane Doe",
      "email_address":"[email protected]"
   }
]

Entendo como obter a lista de participantes separadamente, mas não tenho certeza do que fazer para que ela faça parte da consulta com informações do evento.

A saída não precisa ser estritamente assim, se houver soluções diferentes que sejam mais elegantes sou todo ouvidos.

Vi em alguns planos de consulta que o pai é um Finalize GroupAggregate, mas seus nós filhos são Partial HashAggregates. Quando isso faz sentido?

Por exemplo, tenho uma consulta semelhante a algo como:

=# SELECT x, count(*) AS n FROM t GROUP BY x ;

Não há classificação envolvida, então por que ele escolhe um GroupAggregate no topo? E por que os trabalhadores paralelos estão usando HashAggregate?

"Finalize GroupAggregate  (cost=44630.76..47219.48 rows=10218 width=24) (actual time=270.025..309.145 rows=27909 loops=1)"
"  Group Key: x"
"  ->  Gather Merge  (cost=44630.76..47015.12 rows=20436 width=24) (actual time=270.014..293.964 rows=61056 loops=1)"
"        Workers Planned: 2"
"        Workers Launched: 2"
"        ->  Sort  (cost=43630.73..43656.28 rows=10218 width=24) (actual time=264.612..270.608 rows=20352 loops=3)"
"              Sort Key: x"
"              Sort Method: external merge  Disk: 728kB"
"              Worker 0:  Sort Method: external merge  Disk: 720kB"
"              Worker 1:  Sort Method: external merge  Disk: 776kB"
"              ->  Partial HashAggregate  (cost=39474.60..42950.27 rows=10218 width=24) (actual time=198.285..223.757 rows=20352 loops=3)"
"                    Group Key: x"
"                    Batches: 5  Memory Usage: 1073kB  Disk Usage: 2312kB"
"                    Worker 0:  Batches: 5  Memory Usage: 1073kB  Disk Usage: 1760kB"
"                    Worker 1:  Batches: 5  Memory Usage: 1073kB  Disk Usage: 3400kB"
"                    ->  Parallel Seq Scan on t (cost=0.00..17344.46 rows=345446 width=16) (actual time=0.053..52.217 rows=276357 loops=3)"

Eu também vi algo semelhante nesta pergunta . Embora, neste caso, eu não conheça a consulta original.

Estou usando o sqlwatch para monitorar alguns dos meus servidores e ele tem um trabalho que exclui em lote de uma tabela chamadadbo.sqlwatch_logger_snapshot_header

Tive muitos problemas de locking e bloqueio pois essa tabela é utilizada por diferentes processos, então desabilitei todos os outros jobs com exceção daquele que trata dessa tabela.

Usei o seguinte script para desabilitar todos os outros trabalhos do sqlwatch:

use distribution

set nocount on
set transaction isolation level read uncommitted

declare @Job_id uniqueidentifier
declare @job_name varchar(300)
declare @category_name varchar(300)
declare @body varchar(max)
declare @flag tinyint

declare @enabled bit = 0;  --0 - disable 1-enable
declare @subject varchar(300) = case when @enabled = 0 then 'Disabling  sqlwatch jobs on' + @@servername else 'Enabling sqlwatch jobs on' + @@servername end;
declare @job_enabled bit;

set @flag = 0
set @body = 'The following jobs are going to be ' +
          case when @enabled = 0 then 'Disabled' else 'Enabled' end
          + ' : '+char(10)+Char(13)


IF OBJECT_ID('tempdb.[dbo].[#LogReaderAgents]') IS NOT NULL 
DROP TABLE [dbo].[#LogReaderAgents] 

CREATE TABLE [dbo].[#LogReaderAgents] ( 
[job_id]         UNIQUEIDENTIFIER                 NOT NULL,
[job_name]       SYSNAME                          NOT NULL,
[category_name]  SYSNAME                          NOT NULL,
[enabled]        TINYINT                          NOT NULL)

INSERT INTO [dbo].[#LogReaderAgents] ([job_id],[job_name],[category_name],[enabled])
select job_id, job_name = sj.name, category_name=sc.name, sj.enabled
from  msdb.dbo.sysjobs sj
inner join msdb.dbo.syscategories sc
        on sj.category_id = sc.category_id
where 1=1
  and sj.name like 'SQLWATCH%'
 -- and sc.category_id in (10,13)
 and sj.name not in ('SQLWATCH-INTERNAL-RETENTION')

-- exec sp_gettabledef 'dbo.#LogReaderAgents'
-- exec sp_GetInsertList 'TEMPDB','DBO.#LogReaderAgents'


DECLARE c1 CURSOR FOR
       SELECT Job_id,job_name, category_name, [enabled]
       FROM #LogReaderAgents
OPEN c1
FETCH NEXT FROM c1
       INTO @Job_id,@job_name,@category_name,@job_enabled
       WHILE @@FETCH_STATUS = 0
       begin

              if (select top (1) stop_execution_date from msdb.dbo.sysjobactivity ja
                     where Job_ID = @Job_id
                           and
                     ja.start_execution_date IS NOT NULL
                     order by Start_execution_date desc) is not NULL
              begin
                     set @flag = 1
                     Print @job_name +' is ' + case when @job_enabled=1 then 'Enabled' else 'disabled' end 
                     exec msdb..sp_update_job @job_id = @job_id, @enabled = @enabled
                     set @Body = @Body + char(10)+char(13) + @job_name + ' -- ' + @category_name +' is ' + case when @job_enabled=1 then 'Enabled' else 'disabled' end 
              end
              
              FETCH NEXT FROM c1
       INTO @Job_id,@job_name,@category_name,@job_enabled
       end
CLOSE c1
DEALLOCATE c1

entretanto, depois disso o trabalho ainda está em execução, mas não vejo nenhuma alteração no número de registros que estão nesta tabela.

aqui está o trabalho executando um procedimento e fazendo uma exclusão em lote:

o progresso tem sido lento, mas constante, havia 37,2 milhões de linhas

agora existem 36,9 milhões

então basicamente está funcionando, então tudo bem.

Agora minha pergunta:

Suponha que eu tivesse que interromper este trabalho por qualquer motivo,

é uma exclusão em lote, se eu tivesse que interromper este trabalho agora, quantas linhas foram afetadas, qual seria o custo de reverter o que ainda não foi confirmado?

Tínhamos 2 servidores em um cluster (sem aoag) com SQL + SSIS.

um dos nós do cluster morreu e nós o removemos. planejamos criar um novo nó de cluster e configurar o mecanismo SQL normalmente nele como um recurso de cluster, MAS não nos lembramos se o SSIS também foi configurado como um recurso de cluster.

como o SSIS não reconhece cluster e a MS não recomenda que o SSIS esteja em um recurso de cluster, qual seria a opção aqui? SSIS é apenas um serviço que executa pacotes e estou confuso como posso adicionar um novo nó de cluster SQL junto com o SSIS (o SQL no novo nó é fácil, o problema é o SISS).

funcionaria instalar o SSIS no novo nó do cluster após a instalação do sql e apontar os pacotes para uma unidade compartilhada?

Porque, honestamente, estou confuso sobre o que aconteceria se houvesse um failover para o node2 com o SSIS instalado apenas no Node1.

obrigado.

Existe uma maneira de cancelar um vácuo automático no RDS PostgreSQL? Ao correr

• select pg_cancel_backend(...);
• select pg_terminate_backend(...);

com um usuário que possui a função rds_superuser ocorre um erro:

• ERRO: deve ser um superusuário para cancelar a consulta do superusuário
• ERRO: deve ser um superusuário para encerrar o processo de superusuário

Consulta:

select * from table where col in ( values (?), (?), (?) )

O texto da consulta é gerado e o número de (?) é variável e pode ir até 10.000.

Funciona muito bem, apenas me perguntando se o Postgres armazena em cache a mesma instância do plano para diferentes números de argumentos?

Em outras palavras: qual é a chave para o cache do plano no Postgres? E como isso se aplica à consulta acima?

Eu li a documentação 'Usando COLLATE em instruções SQL' https://dev.mysql.com/doc/refman/8.0/en/charset-collate.html , mas não diz muito sobre o efeito do uso de diferentes valores COLLATE aos exemplos. Apenas como exemplo,

SELECT *
FROM t1
WHERE k LIKE _latin1 'Müller' COLLATE latin1_german2_ci;

Qual é a diferença entre usar valores diferentes depois COLLATE? E se você não usar a COLLATEcláusula? Como encontrar os valores corretos ou possíveis para usar depois COLLATE?

Existe uma prática recomendada para impor a ordem em que as condições de pesquisa são aplicadas? Vimos algumas consultas em que o otimizador reordenou as operações e passou linhas por meio de uma condição e/ou função de pesquisa inesperada e inválida.

Por exemplo:

SELECT * 
FROM table_1
join table_2 on table_1.primary_id = table_2.primary_id
join table_3 on table_2.secondary_id = table_3.secondary_id
WHERE table_3.value is json parseable and table_3.value->>'foo' = bar

Às vezes, essa consulta é otimizada de forma que a pesquisa JSON aconteça antes de garantir que o valor seja analisável em JSON.

Uma situação semelhante pode ocorrer durante a coerção dos tipos:

SELECT * 
FROM table_1
join table_2 on table_1.primary_id = table_2.primary_id and table_2.category_name = 'Foo'
join table_3 on table_2.secondary_id = table_3.secondary_id
-- first do regex to ensure we get a parseable int, then check range
-- column is stored as text as it can be mixed with other non-numerical inputs
WHERE table_3.value ~ E'^\\d{1,9}$' and table_3.value::int < :max_allowed_value_setting;

Parece que a condição de pesquisa de coerção de tipo pode ser reordenada antes da condição de pesquisa regex e/ou que os valores que devem ser filtrados table_2.category_name = 'Foo'são passados ​​primeiro pela conversão de número inteiro porque a ordem de junção foi alterada de table_1 -> table_2 -> table_3para table_1 -> table_3 -> table_2.

Sei que o otimizador de consulta pode reorganizar algumas coisas, mas ainda não tenho certeza de quando isso é aplicável e quando pode causar um problema. O otimizador não tem conhecimento das condições de pesquisa que dependem umas das outras, o que pode levar a erros durante a execução.

Quais partes de uma instrução SQL no PostgreSQL podem ser reorganizadas e existe uma prática recomendada (ou melhor) para lidar com esses tipos de cenários?

Editar: atualize a terminologia para usar condições de pesquisa em vez de restrições