Artashes Khachatryan's questions

Criei 2 tabelas idênticas particionadas por uma coluna inteira. Em uma das tabelas a coluna é computada, na outra tabela a coluna não é computada.

Quando eu consulto a tabela com coluna computada filtrando uma única classificação de partição com índice clusterizado (assumindo que os dados de saída já estão classificados, portanto, nenhuma classificação adicional é necessária), ela verifica a tabela inteira.

CREATE PARTITION FUNCTION pf_test(int) AS RANGE RIGHT FOR VALUES(1, 2, 3, 4)
GO
CREATE PARTITION SCHEME ps_test AS PARTITION pf_test ALL TO([PRIMARY])
GO
CREATE TABLE test_computed
(
    ID BIGINT NOT NULL, 
    ID_C AS CAST(ID % 4 AS INT) PERSISTED, 
    PRIMARY KEY CLUSTERED (ID, ID_C) ON ps_test(ID_C)
) ON ps_test(ID_C)
GO
    
CREATE TABLE test_not_computed
(
    ID BIGINT NOT NULL, 
    ID_C INT NOT NULL, 
    PRIMARY KEY CLUSTERED (ID, ID_C) ON ps_test(ID_C)
) ON ps_test(ID_C)
GO
    
INSERT INTO test_computed(ID)
SELECT TOP 1000000 ROW_NUMBER() OVER(ORDER BY GETDATE())
FROM sys.all_columns a
CROSS JOIN sys.all_columns b
GO
    
INSERT INTO test_not_computed(ID, ID_C)
SELECT TOP 1000000 
    ROW_NUMBER() OVER(ORDER BY GETDATE()), 
    ROW_NUMBER() OVER(ORDER BY GETDATE()) % 4
FROM sys.all_columns a
CROSS JOIN sys.all_columns b
GO

Os dados são idênticos, mas os planos de execução para cada consulta são diferentes.

SELECT TOP 100 *
FROM test_computed
WHERE $partition.pf_test(ID_C) = 1
ORDER BY ID DESC
    
SELECT TOP 100 *
FROM test_not_computed
WHERE $partition.pf_test(ID_C) = 1
ORDER BY ID desc

A tabela real possui bilhões de linhas; estamos usando particionamento para evitar a varredura de toda a tabela.

A versão do SQL Server é

Microsoft SQL Server 2019 (RTM-CU26) (KB5035123) - 15.0.4365.2 (X64)
29 de março de 2024 23:02:47 Copyright (C) 2019 Microsoft Corporation
Developer Edition (64 bits) no Windows Server 2022 Standard 10.0 (Build 20348 :)

Eu tento carregar o teste de um procedimento armazenado de inserção simples

CREATE TABLE _test(ID BIGINT)

CREATE OR alter PROCEDURE dbo.test_sp
AS
BEGIN
    SET NOCOUNT ON;
    BEGIN
        INSERT INTO _test
        SELECT CAST(RAND() * 10000 AS BIGINT)
    END
END

Não quando executo este sp com a ferramenta SQLStress fico SQL Compilation\secigual aBatch Request\sec.

O fato interessante é que SQL Re-Compilations\secé 0.

Ambos optimized for ad-hoce Forced parametrizationestão habilitados. A mesma imagem é mesmo se eu mudar meu sp para um simples SELECT 1. Qualquer ajuda será apreciada. Eu uso o Microsoft SQL Server 2016 (SP3) (KB5003279).

Eu sei que não é uma boa prática ter uma conversão de tipo implícita. Mas esse é um comportamento realmente inesperado quando um valor mais baixo pode de repente se tornar mais alto.

declare @LastSelectedDate DATETIME = '2021-11-09 13:52:29.187'
declare @LastSelectedDate_1 DATETIME2(7) = '2021-11-09 13:52:29.1866667'


SELECT IIF(@LastSelectedDate_1 > CAST(@LastSelectedDate AS DATETIME2), 1, 0)
SELECT IIF(@LastSelectedDate_1 > @LastSelectedDate, 1, 0)

Isso é um bug ou estou perdendo alguma coisa? Estou usando o sql server 2016.

Eu estava testando índices do SQL Server e encontrei um comportamento muito estranho. Aqui está o meu código:

DROP TABLE IF EXISTS  dbo._Test
DROP TABLE IF EXISTS  dbo._Newtest
GO
CREATE TABLE _Test(
ID INT NOT NULL, 
UserSystemID INT NOT NULL, 
Age INT
)
GO
INSERT INTO dbo._Test
        ( ID, UserSystemID, Age )

SELECT TOP 10000000 ABS(CHECKSUM(NEWID())) % 5000000, ABS(CHECKSUM(NEWID())) % 2, ABS(CHECKSUM(NEWID())) % 100
FROM sys.all_columns
CROSS JOIN sys.all_objects a
CROSS JOIN sys.all_objects b
CROSS JOIN sys.all_objects c

; WITH cte AS (
SELECT ID, UserSystemID,  age, ROW_NUMBER() OVER(PARTITION BY ID, UserSystemID ORDER BY GETDATE()) rn
FROM dbo._Test
)

SELECT cte.ID ,
       cte.UserSystemID ,
       cte.Age
INTO _newTest
FROM cte
WHERE cte.rn = 1

CREATE UNIQUE NONCLUSTERED INDEX  IX_test ON dbo._NewTest(ID, UserSystemID) INCLUDE(age)
GO
ALTER TABLE dbo._NewTest ADD CONSTRAINT PK_NewTest PRIMARY KEY CLUSTERED(UserSystemID, ID)
GO

Neste ponto, tenho dois índices na mesma tabela e nas mesmas colunas. O primeiro é não clusterizado e o segundo é clusterizado. A Idcoluna é mais seletiva (cerca de 5.000.000 valores únicos) e UserSystemIDnão (dois valores únicos).

Em seguida, executo a seguinte consulta para testar qual índice é usado:

SELECT id,  UserSystemID, age   
FROM _NewTest
WHERE id = 1502945
AND UserSystemID = 1

Ele busca o índice clusterizado. Você pode ver o plano aqui .

A questão é por que o SQL Server prefere o índice clusterizado em vez do índice exclusivo não clusterizado.

Minha coluna principal de índice clusterizado é muito menos seletiva do que o outro índice exclusivo não clusterizado. Portanto, espero que o desempenho seja pior com o índice clusterizado, mas na prática não é.

Eu tenho uma tabela com 2 colunas, name e related_name.

CREATE TABLE _test(
[name] NVARCHAR(50),
related_name NVARCHAR(50)
)
GO

INSERT INTO dbo._test
([name], related_name)
VALUES

('a', 'b'),
('b', 'c'),
('c', 'd'),
('e', 'f'),
('f', 'g')

Eu quero escrever um UDF, que receberá um nome e retornará todos os nomes relacionados. Se a está relacionado com b e b está relacionado com c, isso significa que a está relacionado com c.

Portanto, o resultado esperado para o parâmetro 'a', 'b', 'c', 'd' deve ser o mesmo.

select * from my_func('a')

O resultado deve ser

result
------
a
b
c
d

E o resultado para

select * from my_func('e')

devemos ser

result
------
e
f
g

Tenho um banco de dados SQL Server com a seguinte estrutura

CREATE TABLE users (
userid INT IDENTITY PRIMARY KEY CLUSTERED, 
age INT
)
GO
CREATE TABLE userstatus(
userstatusID INT IDENTITY PRIMARY KEY CLUSTERED, 
statusid INT, 
userid INT FOREIGN KEY REFERENCES dbo.users(userid)
)
GO

Alguns dados de exemplo:

INSERT  INTO dbo.users
        ( age )
VALUES  ( 15  -- age - int
          ),
        ( 20 ),
        ( 25 );

INSERT  INTO dbo.userstatus
        ( statusid, userid )
VALUES  ( 1, 1 ),
        ( 1, 2 ),
        ( 1, 3 ),
        ( 2, 1 ),
        ( 3, 1 ),
        ( 2, 2 );

Agora quero obter a soma das idades dos usuários e a soma das idades dos usuários que tem status=2.

Algo como:

Idade com status = 2: 35
Idades totais: 60

Eu tenho uma única tabela como

CREATE TABLE Mytable (ID int identity, Name nvarchar(10)); 
GO 
INSERT INTO MyTable (Name) VALUES ('test1'); 
INSERT INTO MyTable (Name) VALUES ('test2'); 
GO 
ALTER TABLE MyTable ADD CONSTRAINT DF_Name DEFAULT('test') FOR Name;

Agora quero atualizar minha coluna Nome assim:

Update MyTable
set name = case ID when 1 then DEFAULT END;

Mas estou recebendo este erro:

Sintaxe incorreta perto da palavra-chave 'DEFAULT'

Como posso usar UPDATEwith DEFAULTna CASEcláusula?

Eu tenho esta instrução SQL:

select * 
from _my_table1 
where 1 = 0 
      and (exists (select 1 from _my_table2 where id =7))

O plano de execução é:

|--Constant Scan

Agora, quando mudo minha consulta para

Declare @i int = 1
SELECT *
FROM dbo._my_table1 
WHERE @i = 0 AND (EXISTS (SELECT 1 FROM dbo._my_table2 WHERE id = 7))

Eu recebo o seguinte plano:

  |--Nested Loops(Left Semi Join)
       |--Filter(WHERE:(STARTUP EXPR([@i]=(0))))
       |    |--Clustered Index Scan(OBJECT:([DEV-RWA_IECMS-DE_Staging_20160301].[dbo].[_my_table1].[PK___my_tabl__3213E83FEF434214]))
       |--Clustered Index Seek(OBJECT:([DEV-RWA_IECMS-DE_Staging_20160301].[dbo].[_my_table2].[PK___my_tabl__3213E83F4D4FA6E2]), SEEK:([DEV-RWA_IECMS-DE_Staging_20160301].[dbo].[_my_table2].[id]=(7)) ORDERED FORWARD)

A questão é por que o SQL Server verifica a segunda parte da WHEREcláusula, se a primeira parte retornar false. Existe alguma solução alternativa para forçar o SQL Engine a não verificar a segunda parte de where, se a primeira parte retornar false.

Eu tenho uma tabela com 2 colunas de nome:

CREATE TABLE Test
(
  TestID int identity primary key clustered
  , Name_Eng nvarchar(50)
  , Name_Nat nvarchar(50)
)

Agora preciso de uma query para pegar essa Namecoluna separada por ,, assim:

    DECLARE @NameColumns NVARCHAR(1024)

            SET @NameColumns = STUFF(
      (SELECT   ',' + 'Test.' + name AS [text()]
       FROM     ( SELECT    c.name
                  FROM      sys.columns c 
                            INNER JOIN sys.tables t ON t.object_id = c.object_id
                  WHERE     t.name = 'Test'
                            AND c.name LIKE 'Name_%'
                ) AS D
                FOR                  XML PATH('') ,
                                         TYPE).value('.[1]', 'VARCHAR(MAX)'), 1, 1,
                                     N'')

select  @NameColumns

Mas esta consulta tem um aviso no plano de execução:

Existe alguma maneira de remover esse aviso?

Tenho uma tabela com 2 colunas:

CREATE TABLE test(
id int, 
name nvarchar(50)
)
go 

insert INTO Test(id, name)
VALUES (1, 'aa')
insert INTO Test(id, name)
VALUES (2, 'bb')
insert INTO Test(id, name)
VALUES (3, 'aa')

Preciso de um procedimento armazenado que selecione dados da minha tabela em ordens diferentes.

    CREATE PROCEDURE testSelect(
@OrderColumnID int
)    
AS 
BEGIN
    SELECT *
    FROM test
    ORDER BY CASE @OrderColumnID WHEN 1 THEN 1 WHEN 2 THEN 2 END ASC
END

WHEN 1 THEN 1 WHEN 2 THEN 2significa que, se input param = 1, a tabela deve ser ordenada pela coluna 'id', se input param = 2, a tabela deve ser ordenada pela coluna 'name'.

Quando executo o SP como:

EXEC dbo.testSelect @OrderColumnID = 2

Obtenho um resultado incorreto.

Não quero reescrever meu SP para usar SQL dinâmico ou separá-lo em if ..... else if .... blocos como

CREATE PROCEDURE testSelect(
@OrderColumnID int
)    
AS 
BEGIN
    IF @OrderColumnID = 1
    SELECT *
    FROM test
    ORDER BY 1
    ELSE IF @OrderColumnID = 2 
    SELECT *
    FROM test
    ORDER BY 2
END

Eu tenho uma tabela no meu banco de dados SQL Server com dados como este:

ID  ParentID
--- ---------
1   NULL
2   1
3   1
5   1
5   4
5   6
8   6
7   9
9   10

Eu preciso de uma selectinstrução que retorne todas as linhas que tenham alguma relação entre elas (não importa pai ou filho). Por exemplo, para id= 1, preciso obter todas as linhas, exceto as duas últimas. O mesmo resultado deve ser para id= 2, 3, 4, 5, 6 ,8. E para id= 7 ou 9 a instrução deve retornar apenas as duas últimas linhas. Tentei resolver esse problema com CTE recursivo, mas falhei.

Eu tenho uma pergunta sobre o desempenho dos gatilhos.

CREATE TABLE [dbo].[_test](
[ID] [INT] IDENTITY(1,1) NOT NULL,
[Date] [DATETIME] NULL,
[DateYearID] [INT] NULL,
[DateQuarterID] [INT] NULL,
[Date1] [DATETIME] NULL,
[Date1YearID] [INT] NULL,
[Date1QuarterID] [INT] NULL)

Agora eu quero ter um gatilho que deve atualizar as colunas DateYearID e DateQuarterID se eu atualizar a coluna Date (ou inserir uma nova linha) e deve atualizar as colunas Date1YearID e Date1QuarterID se eu atualizar a coluna Date1 (ou inserir uma nova linha). O que é melhor, ter um único gatilho como

IF UPDATE(DATE)
   UPDATE _test SET DateYearID = ... , DateQuarterID = ...
IF UPDATE (DATE1)
   UPDATE _test SET Date1YearID = ... , Date1QuarterID = ...

ou ter dois gatilhos diferentes, primeiro deles atualizando as colunas DateYearID,DateQuarterID e o segundo atualizando as colunas DateYear1ID,DateQuarter1ID.

Estou usando o SQLServer 2014.

Muito obrigado pela ajuda.

Desculpe pelo meu inglês ruim :)

Preciso de ajuda para entender a limpeza do armazenamento de versões. Eu tenho a seguinte situação.

1. 12:00 Inicie uma instrução select no nível de isolamento do instantâneo e não confirme.
2. 12:01 Inicie uma instrução de atualização (atualize uma única linha) no nível de isolamento de confirmação de leitura e confirme.
3. 12h02 Inicie uma instrução select no nível de isolamento do instantâneo e não confirme.
4. 12:03 Inicie uma instrução de atualização (atualize uma única linha) no nível de isolamento de leitura confirmada e confirme.

Agora, se olharmos para o armazenamento de versão, como

SELECIONE * DE sys.dm_tran_version_store

veremos 2 linhas (uma linha para cada instrução de atualização).

Agora, se confirmarmos as primeiras transações que começam às 12:00, nenhuma linha será removida do armazenamento de versão (mesmo que passe um minuto).

A pergunta é POR QUE??? .

Na minha opinião, uma das linhas deve ser removida do armazenamento de versão, porque não há nenhuma transação ativa que tenha acesso a essa versão.

Tentei também atualizar não 1 linha, mas 100 linhas (Total mais de 100 KB), mas tenho a mesma situação, o armazenamento de versão não está sendo removido.

Por favor, ajude-me a entender quando o armazenamento de versões está sendo limpo. Muito obrigado pela ajuda.