All perguntas(dba)

Existe algum significado para o SQL Server ter BITdatatype em vez de BOOLEAN? É apenas uma maneira estranha de chamar a mesma coisa, ou existe alguma diferença conceitual sutil?

A documentação sobre BITo tipo de dados menciona:

O tipo de dados bit pode ser usado para armazenar valores booleanos.

Isso parece sugerir que, na verdade, elas não são a mesma coisa.

Estou ciente de que [a coisa que a MS chama de boolean] e [a coisa que a MS chama de bit] são diferentes, MAS do ponto de vista do programador, bité a melhor aproximação do booleanconceito platônico que a linguagem T-SQL oferece. E eu luto para acreditar que seja apenas uma casualidade e não uma intenção. O tipo de dado numérico que aceita apenas 0 e 1 parece pouco prático para outros usos.

Estou executando a configuração do SQL Server 2022 RC1 em um AWS i3.16xlarge com 2 soquetes, 2 nós NUMA, 32 processadores lógicos por nó, 64 processadores lógicos no total.

A configuração está recomendando MAXDOP 8:

Mas se você clicar nesse link para configurar o MAXDOP , as recomendações dizem:

Com base nesse artigo da KB, MAXDOP deve ser 16, não 8. Claro, tecnicamente 8 é menor que 16 - mas também é 2, ou 4, ou 15. De onde vem o 8?

Após a conclusão da instalação do SQL Server e a inicialização do serviço, o log mostra que o SQL Server está implementando automaticamente o Soft-NUMA com 4 nós, cada um com 16 processadores lógicos:

Então, novamente, isso indica que MAXDOP deve ser 16.

Isso é um bug, ou eu perdi algo óbvio? Existe outra regra não escrita em algum lugar que a configuração irá parar no MAXDOP 8?

Preciso truncar uma tabela com 17 bilhões de linhas, a tabela está em um banco de dados que faz parte de um AG.

Qual será o efeito dessa operação na latência do AG e no tamanho dos backups de log?

Existe uma maneira recomendada de fazer isso?

Eu executo um banco de dados SQL Server 2016 onde tenho a seguinte tabela com mais de 100 milhões de linhas:

StationId | ParameterId |       DateTime       | Value
    1     |      2      | 2020-02-04 15:00:000 |  5.20
    1     |      2      | 2020-02-04 14:00:000 |  5.20
    1     |      2      | 2020-02-04 13:00:000 |  5.20
    1     |      3      | 2020-02-04 15:00:000 |  2.81
    1     |      3      | 2020-02-04 14:00:000 |  2.81
    1     |      4      | 2020-02-04 15:00:000 |  5.23
    2     |      2      | 2020-02-04 15:00:000 |  3.70
    2     |      4      | 2020-02-04 15:00:000 |  12.20
    3     |      2      | 2020-02-04 15:00:000 |  1.10

Esta tabela possui um índice clusterizado para StationId, ParameterId e DateTime, nesta ordem, todos crescentes.

O que eu preciso é, para cada par exclusivo StationId - ParameterId, retornar o valor mais recente da coluna DateTime:

StationId | ParameterId |       LastDate       
    1     |      2      | 2020-02-04 15:00:000 
    1     |      3      | 2020-02-04 15:00:000 
    1     |      4      | 2020-02-04 15:00:000 
    2     |      2      | 2020-02-04 15:00:000 
    2     |      4      | 2020-02-04 15:00:000 
    3     |      2      | 2020-02-04 15:00:000 

O que estou fazendo agora é a seguinte consulta, que leva cerca de 90 a 120 segundos para ser executada:

    SELECT StationId, ParameterId, MAX(DateTime) AS LastDate
    FROM  MyTable WITH (NOLOCK)
    GROUP BY StationId, ParameterId

Também vi muitos posts sugerindo o seguinte, que leva mais de 10 minutos para ser executado:

    SELECT StationId, ParameterId, DateTime AS LastDate
    FROM
    (
       SELECT StationId, ParameterId, DateTime
       ,ROW_NUMBER() OVER (PARTITION BY StationId,ParameterIdORDER BY DateTime DESC) as row_num
       FROM  MyTable WITH (NOLOCK)
    )
    WHERE row_num = 1

Mesmo no melhor caso (usando a cláusula GROUP BY e a função agregada MAX), o plano de execução não indica uma busca de índice:

Gostaria de saber se existe uma maneira melhor de realizar essa consulta (ou construir o índice) para obter um melhor tempo de execução.

O SQL Server 2019 CTP 2.3 adicionou algumas novas colunas a sys.databases, incluindo is_result_set_caching_on:

Ainda não está documentado nas Novidades do SQL Server 2019 , nem na página ALTER DATABASE .

Eu tentei usar a mesma sintaxe do Accelerated Database Recovery apenas para rir:

ALTER DATABASE StackOverflow2013 SET RESULT_SET_CACHING ON;

Mas sem sorte:

Msg 5058, Level 16, State 12, Line 8
Option 'RESULT_SET_CACHING' cannot be set in database 'StackOverflow2013'.

Vindo para SQL de outras linguagens de programação, a estrutura de uma consulta recursiva parece bastante estranha. Ande por ela passo a passo, e ela parece desmoronar.

Considere o seguinte exemplo simples:

CREATE TABLE #NUMS
(N BIGINT);

INSERT INTO #NUMS
VALUES (3), (5), (7);

WITH R AS
(
    SELECT N FROM #NUMS
    UNION ALL
    SELECT N*N AS N FROM R WHERE N*N < 10000000
)
SELECT N FROM R ORDER BY N;

Vamos percorrê-lo.

Primeiro, o membro âncora é executado e o conjunto de resultados é colocado em R. Assim, R é inicializado como {3, 5, 7}.

Então, a execução cai abaixo de UNION ALL e o membro recursivo é executado pela primeira vez. Ele é executado em R (ou seja, no R que temos atualmente em mãos: {3, 5, 7}). Isso resulta em {9, 25, 49}.

O que ele faz com esse novo resultado? Ele anexa {9, 25, 49} ao {3, 5, 7} existente, rotula a união resultante R e então continua com a recursão a partir daí? Ou ele redefine R para ser apenas este novo resultado {9, 25, 49} e faz toda a união depois?

Nenhuma das escolhas faz sentido.

Se R agora for {3, 5, 7, 9, 25, 49} e executarmos a próxima iteração da recursão, terminaremos com {9, 25, 49, 81, 625, 2401} e teremos perdeu {3, 5, 7}.

Se R agora é apenas {9, 25, 49}, então temos um problema de rotulagem incorreta. R é entendido como a união do conjunto de resultados do membro âncora e todos os conjuntos de resultados do membro recursivo subsequentes. Considerando que {9, 25, 49} é apenas um componente de R. Não é o R completo que acumulamos até agora. Portanto, escrever o membro recursivo selecionando de R não faz sentido.

Eu certamente aprecio o que @Max Vernon e @Michael S. detalharam abaixo. Ou seja, que (1) todos os componentes são criados até o limite de recursão ou conjunto nulo, e então (2) todos os componentes são unidos. É assim que entendo a recursão SQL para realmente funcionar.

Se estivéssemos redesenhando o SQL, talvez pudéssemos impor uma sintaxe mais clara e explícita, algo assim:

WITH R AS
(
    SELECT   N
    INTO     R[0]
    FROM     #NUMS
    UNION ALL
    SELECT   N*N AS N
    INTO     R[K+1]
    FROM     R[K]
    WHERE    N*N < 10000000
)
SELECT N FROM R ORDER BY N;

Mais ou menos como uma prova indutiva em matemática.

O problema com a recursão SQL como está atualmente é que ela é escrita de maneira confusa. A forma como está escrito diz que cada componente é formado selecionando de R, mas isso não significa o R completo que foi (ou parece ter sido) construído até agora. Significa apenas o componente anterior.

Não consigo encontrar nenhuma referência ao tipo de dados 'name' na documentação do postgres, mas estou vendo-o como um tipo de dados na tabela pgagent.pga_jobstep para a coluna 'jstdbname'. O udt_name também é 'nome'. Selecionar as linhas dessa tabela faz com que elas apareçam como se fossem strings.

Não está listado aqui: Tipos de dados Postgres

Estou intrigado com esse problema há quase 1 semana. Espero que alguém em nossa comunidade tenha experimentado o mesmo problema e já tenha encontrado uma solução.

Então aqui está meu problema:

De acordo com a política da nossa empresa, queremos que o correio do banco de dados possa enviar e-mails pela porta 25 com TLS 1.2 ativado e com TLS 1.0 e TLS 1.1 desativados.

Nosso servidor de email é o Exchange Server 2010, nossas caixas SQL Server 2016 (edições Developer e Enterprise) possuem SO das edições Windows Server 2016 Standard.

Nossa versão do SQL Server é:

select @@version
----------------------------------------
Microsoft SQL Server 2016 (SP1-CU7-GDR) (KB4057119) - 13.0.4466.4 (X64) 
    Dec 22 2017 11:25:00 
    Copyright (c) Microsoft Corporation
    Developer Edition (64-bit) on Windows Server 2016 Datacenter 10.0 <X64> (Build 14393: ) (Hypervisor)

Temos a configuração de correio do banco de dados conforme mostrado aqui.

O problema é sempre que ativamos o SSL

use msdb
exec dbo.sysmail_update_account_sp @account_id=2, @enable_ssl = 1;

NÃO PODEMOS enviar email db (não importa se nossa autenticação SMTP é Autenticação do Windows, Autenticação básica ou Autenticação anônima). A mensagem de erro no log de email do db é a seguinte:

Mensagem

O correio não pôde ser enviado aos destinatários devido a uma falha no servidor de correio. (Enviando e-mail usando a conta 2 (2018-07-30T10:52:41). Mensagem de exceção: não é possível enviar e-mails para o servidor de e-mail. (Falha ao enviar e-mail.). )

Mas se desligarmos este SSL, não há problema para o envio de e-mail db.

Então, como podemos habilitar o SSL e usar o TLS 1.2 para db mail?

Eu habilitei o TLS 1.2 adicionando o registro conforme mostrado abaixo

Os detalhes estão neste link (consulte a seção de perguntas frequentes)

Eu tenho dois índices exclusivos em colunas ae b. Eu preciso de algo assim:

insert into my_table (a, b) values (1, 2), (1, 2)
on conflict (a) do update set c = 'a_violation'
on conflict (b) do update set c = 'b_violation'

Então, geralmente, eu quero fazer uma atualização diferente com base no alvo do conflito - a sintaxe acima não é suportada (apenas uma on conflictinstrução é suportada). Existe alguma outra maneira de fazer isso?

Eu quero ser capaz de executar uma consulta para obter as informações cruciais sobre o status de um banco de dados. Ou seja, eu quero que a consulta seja capaz de dizer se o banco de dados está ou não em bom estado.

Esta é a consulta que herdei para esta verificação:

SELECT name AS [SuspectDB],
  DATABASEPROPERTY(name, N'IsSuspect') AS [Suspect],
  DATABASEPROPERTY(name, N'IsOffline') AS [Offline],
  DATABASEPROPERTY(name, N'IsEmergencyMode') AS [Emergency],
  has_dbaccess(name) AS [HasDBAccess]
FROM sysdatabases
WHERE (DATABASEPROPERTY(name, N'IsSuspect') = 1)
   OR (DATABASEPROPERTY(name, N'IsOffline') = 1)
   OR (DATABASEPROPERTY(name, N'IsEmergencyMode') = 1)
   OR (has_dbaccess(name) = 0)

Se essa consulta retornar algum resultado, a suposição feita é que o banco de dados está em um estado suspeito ou potencialmente ruim.

Existe uma maneira melhor de fazer isso?