Suleyman Essa's questions

Eu estava lendo isso e fiz o seguinte:

go
create table fiirst (
col1 int,
col2 int
);
create table seecond(
col1 int,
col2 int
);
with
n1(c) as (select 0 union all select 0 ),
n2(c) as ( select 0 from n1 as t1 cross join n1 as t2),
n3(c) as ( select 0 from n2 as t1 cross join n2 as t2),
n4(c) as (select 0 from n3 as t1 cross join n3 as t2),
ids(id) as (select ROW_NUMBER() over (order by (select null)) from n4)
insert into fiirst(col1,col2)
select id,id 
from ids;
with
n1(c) as (select 0 union all select 0 ),
n2(c) as ( select 0 from n1 as t1 cross join n1 as t2),
n3(c) as ( select 0 from n2 as t1 cross join n2 as t2),
n4(c) as (select 0 from n3 as t1 cross join n3 as t2),
ids(id) as (select ROW_NUMBER() over (order by (select null)) from n4)
insert into seecond(col1,col2)
select id,id
from ids;
----Craig Freedman's query

select *
from fiirst
where fiirst.col1 > (
    select min(seecond.col1)
    from seecond
    where seecond.col2 < fiirst.col2
);

E eu obtive um spool de índice , mesmo a tabela sendo um heap. A questão é: como isso aconteceu? Por que eu obtenho um spool de índice em um heap? No exemplo mencionado no link acima, não havia linhas, então não havia spools, mas aqui eu os vejo?

Nos documentos diz que podemos compartilhar varreduras de índice (varredura avançada). Agora, aqui eles usaram estatísticas e estatísticas de espera e eu não encontrei uma sessão de eventos estendida que pudesse identificá-la diretamente.

A questão é: como posso saber que uma varredura avançada foi usada? Eu sei sobre a propriedade falsa ordenada, mas isso apenas diz que ela não usou a ordem na chave de índice?

No AdventureWorks2016 quando executo a seguinte consulta:

USE AdventureWorks2016

BEGIN TRAN;
SELECT 
    Sales.SalesOrderHeader.SalesOrderID
FROM 
    Sales.SalesOrderHeader
JOIN 
    Sales.Customer 
    ON Sales.SalesOrderHeader.CustomerID = Sales.Customer.CustomerID
OPTION (RECOMPILE, QUERYTRACEON 8605, QUERYTRACEON 8606, QUERYTRACEON 8607, QUERYTRACEON 3604);
COMMIT TRAN;
GO

Recebo uma varredura não agrupada no CustomerID ( o plano ), portanto, eliminação da chave estrangeira. Funcionou também com o esquema de compras ( o plano ), mas nesta consulta ( o plano ):

BEGIN TRAN 
SELECT P.ProductModelID
FROM Production.Product P
JOIN Production.ProductModel PM
ON P.ProductModelID = PM.ProductModelID
OPTION (RECOMPILE, QUERYTRACEON 8605, QUERYTRACEON 8606, QUERYTRACEON 8607, QUERYTRACEON 3604);
COMMIT TRAN 

Ou ( o plano ):

BEGIN TRAN 
SELECT P.ProductID
FROM Production.Product P
JOIN Production.ProductModel PM
ON P.ProductModelID = PM.ProductModelID
OPTION (RECOMPILE, QUERYTRACEON 8605, QUERYTRACEON 8606, QUERYTRACEON 8607, QUERYTRACEON 3604);
COMMIT TRAN 

Recebo varreduras com junções no meu editor de diagramas no SSMS 21:

(name)
FK_Product_ProductModel_ProductModelID
description
Foreign key constraint referencing ProductModel.ProductModelID.

Eu o reativei antes de postar a pergunta, ainda tinha o mesmo plano. A chave estrangeira é

• Confiável
• Não desabilitado
• Não permite nulos
• Não é um esquema diferente

A questão é: por que não estou eliminando a chave estrangeira?

Existem dois níveis de dobramento constante, um na árvore de conversão e outro na fase de simplificação?

Se eu executar a seguinte consulta

SELECT 
    P.[ProductID]
FROM 
    Production.Product AS P
WHERE
    P.[ProductID] = 1 + 2 * 3
    OPTION (RECOMPILE, QUERYTRACEON 8605, QUERYTRACEON 8606, QUERYTRACEON 8607, QUERYTRACEON 3604);

Na árvore de conversão, encontro uma constante, então eu chamaria isso de dobramento de constante básica?

como Paul Holmes diz neste exemplo, mas se eu executar esta consulta de Paul White

use AdventureWorks2016
begin tran 
SELECT
    P.[Name]
FROM Production.Product AS P
WHERE
    P.[Name] LIKE 
        SUBSTRING(LEFT(CHAR(ASCII(CHAR(68))), 1) + '%', 1, 2)
OPTION (RECOMPILE, QUERYTRACEON 8605, QUERYTRACEON 8606, QUERYTRACEON 8607, QUERYTRACEON 3604);
commit tran

e

begin tran 
SELECT
    P.[Name]
FROM Production.Product AS P
WHERE
    P.[Name] LIKE 
        'd%'
OPTION (RECOMPILE, QUERYTRACEON 8605, QUERYTRACEON 8606, QUERYTRACEON 8607, QUERYTRACEON 3604);
commit tran 

Não vejo muita diferença entre ambos em termos de árvores de conversão, então a dobra constante aconteceu aqui e suas árvores simplificadas têm os mesmos operadores?

Existem diferentes estágios no dobramento constante? Onde eles estão? O que eu fiz de errado aqui, então não vi na fase de simplificação?

então a simplificação no algebrizador deve converter algumas das subconsultas em junções internas ou externas. por exemplo, eu tentei isso

DBCC TRACEON(3604)
USE ContosoRetailDW
BEGIN TRAN 
SELECT ProductKey
FROM DimProduct 
WHERE ProductKey IN (SELECT ProductKey 
                     FROM FactSales
                     WHERE SALESKEY <2) 
OPTION(RECOMPILE,QUERYTRACEON 8605)
COMMIT TRAN 

a saída foi

*** Converted Tree: ***
    LogOp_Project QCOL: [ContosoRetailDW].[dbo].[DimProduct].ProductKey

        LogOp_Select

            LogOp_Get TBL: DimProduct DimProduct TableID=117575457 TableReferenceID=0 IsRow: COL: IsBaseRow1000 

            ScaOp_SomeComp 2

                ScaOp_Identifier QCOL: [ContosoRetailDW].[dbo].[DimProduct].ProductKey

                LogOp_Project

                    LogOp_Select

                        LogOp_Get TBL: FactSales FactSales TableID=1602104748 TableReferenceID=0 IsRow: COL: IsBaseRow1002 

                        ScaOp_Comp x_cmpLt

                            ScaOp_Identifier QCOL: [ContosoRetailDW].[dbo].[FactSales].SalesKey

                            ScaOp_Const TI(int,ML=4) XVAR(int,Not Owned,Value=2)

                    AncOp_PrjList 

        AncOp_PrjList 

*******************

se eu reescrever assim

BEGIN TRAN;
SELECT DISTINCT dp.ProductKey
FROM DimProduct dp
JOIN FactSales fs ON dp.ProductKey = fs.ProductKey
WHERE fs.SalesKey < 2
OPTION (RECOMPILE, QUERYTRACEON 8605);
COMMIT TRAN;

Eu entendo

*** Converted Tree: ***
    LogOp_GbAgg OUT(QCOL: [dp].ProductKey,) BY(QCOL: [dp].ProductKey,)

        LogOp_Project

            LogOp_Project QCOL: [dp].ProductKey

                LogOp_Select

                    **LogOp_Join**

                        LogOp_Get TBL: DimProduct(alias TBL: dp) DimProduct TableID=117575457 TableReferenceID=0 IsRow: COL: IsBaseRow1000 

                        LogOp_Get TBL: FactSales(alias TBL: fs) FactSales TableID=1602104748 TableReferenceID=0 IsRow: COL: IsBaseRow1001 

                        ScaOp_Comp x_cmpEq

                            ScaOp_Identifier QCOL: [dp].ProductKey

                            ScaOp_Identifier QCOL: [fs].ProductKey

                    ScaOp_Comp x_cmpLt

                        ScaOp_Identifier QCOL: [fs].SalesKey

                        ScaOp_Const TI(int,ML=4) XVAR(int,Not Owned,Value=2)

                AncOp_PrjList 

            AncOp_PrjList 

        AncOp_PrjList 

*******************

Então, a questão é: Como posso obter o LogOp_Join na primeira consulta?

Tentei criar uma tabela similar com 50 milhões de linhas, mas ainda não aconteceu. Quais são as condições que fazem isso acontecer?