All perguntas(dba)

O SQL Server 2019 CTP3.1 introduziu uma otimização para lidar com a contenção de inserção de última página. Isso assume a forma de uma opção de índice chamada OPTIMIZE_FOR_SEQUENTIAL_KEY.

Imagina-se que isso poderia ser uma adaptação de Bw-Tree ou Bz-Tree . No entanto, eles dependem de páginas de tamanho variável, enquanto o mecanismo de armazenamento atual requer páginas de tamanho fixo.

Como a otimização é implementada? Como os algoritmos B-Tree atuais são alterados por essa otimização? Em que circunstâncias eu escolheria não implantar essa opção?

Pesquisar

Uma patente para uma abordagem de chave reversa .

Dei uma olhada rápida usando DBCC PAGE, comparando 2017 com 2019 e 2019 com e sem OPTIMIZE_FOR_SEQUENTIAL_KEY em um índice clusterizado exclusivo para uma coluna int IDENTITY. Não havia nada que obviamente explicasse o novo comportamento. Isso me faz pensar que é uma coisa algorítmica, ao invés de uma coisa estrutural, o que faz sentido.

Uma postagem no blog do MS.

Este recurso parece centrar-se na detecção e prevenção de comboios .

Temos PCs com SQL Server (2008 SP4 e 2016 SP1) que perdem energia regularmente. Obviamente, isso às vezes leva à corrupção (índice) do banco de dados SQL Server, que precisamos restaurar posteriormente.

Estou ciente de que o SQL Server não foi projetado para esses cenários e a solução correta é corrigir a causa da perda de energia (mais sobre isso abaixo, se você estiver curioso). No entanto, existem opções de ajuste no SQL Server que eu possa definir para reduzir o risco de corrupção do banco de dados na perda de energia ?

Background: O "PC" é um tablet Windows montado em uma empilhadeira. Quando o usuário desliga a empilhadeira, o tablet fica sem energia. Tentamos ensinar os usuários a desligar corretamente o Windows antes de desligar a empilhadeira, mas falhamos (provavelmente porque apenas desligá-lo "funciona" na maioria das vezes). No momento, também estamos investigando outras opções, como adicionar um no-break que avisa o tablet para desligar em caso de perda de energia.

Qual é a diferença entre as duas funções a seguir

• gen_random_uuid()fornecido por pgcryptoextensão
• uuid_generate_v4()fornecido por uuid-osspextensão

Ambos são os mesmos nos bastidores? Algum impacto no desempenho ao usar um?

Estou executando o Ubuntu 16. Instalei o Postgresql. Postgresql costumava funcionar, mas depois reiniciei.

Os comandos nmap mostram que a porta 5432 está aberta. Postgres parece estar funcionando corretamente:

service postgresql status

postgresql.service - PostgreSQL RDBMS Carregado: carregado (/lib/systemd/system/postgresql.service; habilitado; predefinição do fornecedor: habilitado) Ativo: ativo (saído) desde 29-07-2017 18:42:59 EDT; 1min 4s atrás Processo: 201 ExecStart=/bin/true (code=exited, status=0/SUCCESS) PID principal: 201 (code=exited, status=0/SUCCESS)
Memória: 0B CGroup: /system.slice/postgresql. serviço

Eu corri isso:psql

Mas consegui isso:

psql: não foi possível conectar ao servidor: Arquivo ou diretório inexistente O servidor está executando localmente e aceitando conexões no soquete de domínio Unix "/var/run/postgresql/.s.PGSQL.5432"?

O arquivo listado acima parece não existir.

Como entro no Postgresql? Normalmente eu corria psqlou sudo -i -u postgresentão psql. Mas esses comandos não estão funcionando. Eu continuo recebendo um erro sobre "não foi possível conectar ao servidor". Várias reinicializações não ajudaram.

Atualizar:

Executei este comando:dpkg -l | grep postgres

rc postgresql-9.5 9.5.6-0ubuntu0.16.04 amd64 banco de dados SQL relacional de objeto, servidor versão 9.5
ii postgresql-client 9.5+173 todos os programas front-end para PostgreSQL (versão suportada)
ii postgresql-client-9.5 9.5.7-0ubuntu0.16.04 amd64 programas front-end para PostgreSQL 9.5
ii postgresql-client-common 173 all manager para várias versões do cliente PostgreSQL
ii postgresql-common 173 all PostgreSQL gerenciador de cluster de banco de dados

Estou fazendo esta pergunta para entender melhor o comportamento do otimizador e entender os limites em torno dos spools de índice. Suponha que eu coloque inteiros de 1 a 10000 em um heap:

CREATE TABLE X_10000 (ID INT NOT NULL);
truncate table X_10000;

INSERT INTO X_10000 WITH (TABLOCK)
SELECT TOP 10000 ROW_NUMBER() OVER (ORDER BY (SELECT NULL))
FROM master..spt_values t1
CROSS JOIN master..spt_values t2;

E force uma junção de loop aninhado com MAXDOP 1:

SELECT *
FROM X_10000 a
INNER JOIN X_10000 b ON a.ID = b.ID
OPTION (LOOP JOIN, MAXDOP 1);

Esta é uma ação bastante hostil para o SQL Server. As junções de loop aninhadas geralmente não são uma boa opção quando ambas as tabelas não têm índices relevantes. Aqui está o plano:

A consulta leva 13 segundos na minha máquina com 100000000 linhas buscadas no spool da tabela. No entanto, não vejo por que a consulta deve ser lenta. O otimizador de consulta tem a capacidade de criar índices em tempo real por meio de spools de índice . Esta consulta parece ser um candidato perfeito para um spool de índice.

A consulta a seguir retorna os mesmos resultados que a primeira, tem um spool de índice e termina em menos de um segundo:

SELECT *
FROM X_10000 a
CROSS APPLY (SELECT TOP (9223372036854775807) b.ID FROM X_10000 b WHERE a.ID = b.ID) ca
OPTION (LOOP JOIN, MAXDOP 1);

Essa consulta também possui um spool de índice e termina em menos de um segundo:

SELECT *
FROM X_10000 a
INNER JOIN X_10000 b ON a.ID >= b.ID AND a.ID <= b.ID
OPTION (LOOP JOIN, MAXDOP 1);

Por que a consulta original não tem um spool de índice? Existe algum conjunto de dicas documentadas ou não documentadas ou sinalizadores de rastreamento que fornecerão um spool de índice? Encontrei esta pergunta relacionada , mas ela não responde totalmente à minha pergunta e não consigo fazer com que o sinalizador de rastreamento misterioso funcione para essa consulta.

Alguém estava revisando meu código DDL para criar tabelas e sugeriu, quando viram que eu vi usando VARCHAR(256)campos para texto, espero que sejam bem pequenos, como um primeiro nome ou qualquer outra coisa, que eu deveria sempre usar VARCHAR(MAX)e vincular Por que usar qualquer coisa além de varchar (max ) . Eu li, mas parecia datado, pois estava focado em 2005, e não parecia oferecer nenhuma justificativa real para alocar potencialmente até 2 GB por linha em todos os campos de texto.

De um ponto de vista de desempenho, armazenamento etc., como alguém deve decidir se deve usar VARCHAR(MAX)ou um tipo menor e mais específico para versões modernas do SQL Server? (por exemplo, 2008, 2012, 2014)

Eu tenho um banco de dados SQL Server 2012. Percebi valor Reason for early termination of statement optimizationpara algumas consultas e todas deram Good Enough Plan Found. Agora minhas perguntas são:

1. Quais são todos os tipos possíveis de “Razão para término antecipado da otimização de instrução”. Eu procurei por isso no msdn, mas não obtive uma lista completa de valores.

2. Existe um DMV ou evento estendido para listar todas as consultas para as quais a otimização foi encerrada devido a outros motivos que não o Plano Bom o Suficiente Encontrado? Referi-me a seguir dois artigos que não listam a lista completa de possibilidades. [Além disso, eles me dão resultados diferentes no meu banco de dados].

   • Descoberta: tempo limite de compilação da consulta
   • Identificando planos de consulta que não são bons o suficiente

Eu tenho esta tabela:

CREATE TABLE [dbo].[Accounts] (
    [AccountId] UNIQUEIDENTIFIER UNIQUE NOT NULL DEFAULT NEWID(),
    -- WHATEVER other columns
);
GO
CREATE UNIQUE CLUSTERED INDEX [AccountsIndex]
    ON [dbo].[Accounts]([AccountId] ASC);
GO

Esta consulta:

DECLARE @result UNIQUEIDENTIFIER
SELECT @result = AccountId FROM Accounts WHERE AccountId='guid-here'

executa com um plano de consulta que consiste em uma única busca de índice - como esperado:

SELECT <---- Clustered Index Seek

Esta consulta faz o mesmo:

DECLARE @result UNIQUEIDENTIFIER
SET @result = (SELECT AccountId FROM Accounts WHERE AccountId='guid-here')

mas é executado com um plano em que o resultado do Index Seek é Left Outer Joined com o resultado de alguma Constant Scan e, em seguida, alimentado no Compute Scalar:

SELECT <--- Compute Scalar <--- Left Outer Join <--- Constant Scan
                                      ^
                                      |------Clustered Index Seek

O que é essa magia extra? O que faz a Varredura Constante seguida pela Junção Externa Esquerda?

Eu tenho um procedimento armazenado que armazena valores em uma variável de tabela. Eu seleciono esses valores e os retorno quando o procedimento é chamado.

Estou tentando definir esses valores de retorno em outra variável de tabela, mas não consigo descobrir.

Procedimento armazenado

ALTER PROCEDURE [dbo].[GetOrSetDomainId]
@DomainName varchar(50),
@DomainUrl varchar(50)
AS
BEGIN
    DECLARE @DomainId bigint;
    DECLARE @NumberOfRwos bigint;

    DECLARE @DomainHistory TABLE
    (
        DomainId bigint, 
        HasHistory bit,
        ServerOnline bit,
        DatabaseOnline bit, 
        ServerPerformance bigint,
        DatabasePerformance bigint, 
        SoldTickets bigint
    )


    SELECT  @NumberOfRwos =  COUNT(Id) 
    FROM DomainData
    WHERE DomainName = @DomainName OR DomainUrl = @DomainUrl

    IF(@NumberOfRwos = 0)
    BEGIN
        INSERT INTO DomainData (DomainName, DomainUrl) VALUES (@DomainName, @DomainUrl)

         SELECT @DomainId =  @@IDENTITY

         INSERT INTO @DomainHistory(DomainId,HasHistory)VALUES(@DomainId, 0)

         SELECT * FROM @DomainHistory
    END

    ELSE
    BEGIN
    ---not important here----
    END

END

Código de chamada

Eu chamo o procedimento usando:

DECLARE @DomainHistory TABLE
(
    DomainId bigint, 
    HasHistory bit,
    ServerOnline bit,
    DatabaseOnline bit, 
    ServerPerformance bigint,
    DatabasePerformance bigint, 
    SoldTickets bigint
)

SET @DomainHistory = EXEC GetOrSetDomainId 'test', 'test2'
---Other alternatives:---
INSERT INTO @DomainHistory(DomainId,HasHistory)
VALUES(EXEC GetOrSetDomainId 'test', 'test2')

Como posso fazer isso?

Eu queria perguntar o significado deste fragmento do documento do Postgres em relação ao varchar(n)tipo:

O requisito de armazenamento para uma string curta (até 126 bytes) é de 1 byte mais a string real, que inclui o preenchimento de espaço no caso de caractere. Strings mais longas têm 4 bytes de sobrecarga em vez de 1.

Vamos supor que eu tenha um varchar(255)campo. E agora, as seguintes afirmações:

• Se esse campo contiver uma string de 10 bytes, a sobrecarga será de 1 byte. Portanto, a string usará 11 bytes.
• Se o campo contiver string usando 140 bytes, a sobrecarga será de 4 bytes. Portanto, a string usará 144 bytes.

Essas afirmações acima são verdadeiras? Aqui alguém entende o documento da mesma forma que eu, mas aqui alguém afirma que a sobrecarga é sempre de 4 bytes aqui ?