O guia fácil sobre como usar subconsultas no SQL Server

Subconsultas SQL – O que são?

SELECT 
 col1
,col2
,(subquery) as col3
FROM table1
[JOIN table2 ON table1.col1 = table2.col2]
WHERE col1 <operator> (subquery)

• Sintaxe de subconsulta SQL dependendo de diferentes tipos e operadores de subconsulta.
• Quando e em que tipo de declarações se pode usar uma subconsulta.
• Implicações de desempenho x JOINs .
• Avisos comuns ao usar subconsultas SQL.

Faça subconsultas SQL independentes ou correlacionadas

-- Get sales orders of customers from Southwest United States 
-- (TerritoryID = 4)

USE [AdventureWorks]
GO
SELECT CustomerID, SalesOrderID
FROM Sales.SalesOrderHeader
WHERE CustomerID IN (SELECT [CustomerID]
                     FROM [AdventureWorks].[Sales].[Customer]
                     WHERE TerritoryID = 4)

USE [AdventureWorks]
GO
SELECT DISTINCT a.LastName, a.FirstName, b.BusinessEntityID
FROM Person.Person AS p
JOIN HumanResources.Employee AS e ON p.BusinessEntityID = e.BusinessEntityID
WHERE 1262000.00 IN
    (SELECT [SalesQuota]
    FROM Sales.SalesPersonQuotaHistory spq
    WHERE p.BusinessEntityID = spq.BusinessEntityID)

• isolar a subconsulta.
• substitua a referência à consulta externa por um valor constante.

SELECT [SalesQuota]
    FROM Sales.SalesPersonQuotaHistory spq
    WHERE spq.BusinessEntityID = <constant value>

Faça subconsultas SQL com 3 possíveis valores retornados

• Um único valor
• Vários valores
• Tabelas inteiras

Valor único

-- Output a single value which is the maximum or last TransactionID
USE [AdventureWorks]
GO
SELECT TransactionID, ProductID, TransactionDate, Quantity
FROM Production.TransactionHistory
WHERE TransactionID = (SELECT MAX(t.TransactionID) 
                       FROM Production.TransactionHistory t)

Msg 512, Level 16, State 1, Line 20
Subquery returned more than 1 value. This is not permitted when the subquery follows =, !=, <, <= , >, >= or when the subquery is used as an expression.

Vários valores

-- Output multiple values which is a list of customers with lastnames that --- start with 'I'

USE [AdventureWorks]
GO
SELECT [SalesOrderID], [OrderDate], [ShipDate], [CustomerID]
FROM Sales.SalesOrderHeader
WHERE [CustomerID] IN (SELECT c.[CustomerID] FROM Sales.Customer c
INNER JOIN Person.Person p ON c.PersonID = p.BusinessEntityID
WHERE p.lastname LIKE N'I%' AND p.PersonType='SC')

Valores da tabela inteira

-- Output a table of values based on sales orders
USE [AdventureWorks]
GO
SELECT [ShipYear],
COUNT(DISTINCT [CustomerID]) AS CustomerCount
FROM (SELECT YEAR([ShipDate]) AS [ShipYear], [CustomerID] 
      FROM Sales.SalesOrderHeader) AS Shipments
GROUP BY [ShipYear]
ORDER BY [ShipYear]

• Todas as colunas na subconsulta devem ter nomes exclusivos. Assim como uma tabela física, uma tabela derivada deve ter nomes de coluna exclusivos.
• ORENDER POR não é permitido a menos que TOP também é especificado. Isso porque a tabela derivada representa uma tabela relacional em que as linhas não têm ordem definida.

-- Output multiple values which is a list of customers with lastnames that start with 'I'
USE [AdventureWorks]
GO
SELECT o.[SalesOrderID], o.[OrderDate], o.[ShipDate], o.[CustomerID]
FROM Sales.SalesOrderHeader o
INNER JOIN Sales.Customer c on o.CustomerID = c.CustomerID
INNER JOIN Person.Person p ON c.PersonID = p.BusinessEntityID
WHERE p.LastName LIKE N'I%' AND p.PersonType = 'SC'

Outras instruções em que você pode usar subconsultas SQL

Usando subconsultas SQL em instruções UPDATE

-- In the products inventory, transfer all products of Vendor 1602 to ----
-- location 6
USE [AdventureWorks]
GO
UPDATE [Production].[ProductInventory]
SET LocationID = 6
WHERE ProductID IN
    (SELECT ProductID
     FROM Purchasing.ProductVendor
     WHERE BusinessEntityID = 1602)
GO

Usando subconsultas SQL em instruções INSERT

-- Impose a salary increase for all employees in DepartmentID 6 
-- (Research and Development) by 10 (dollars, I think) 
-- effective June 1, 2020
USE [AdventureWorks]
GO
INSERT INTO [HumanResources].[EmployeePayHistory]
([BusinessEntityID]
,[RateChangeDate]
,[Rate]
,[PayFrequency]
,[ModifiedDate])
SELECT
a.BusinessEntityID
,'06/01/2020' as RateChangeDate
,(SELECT MAX(b.Rate) FROM [HumanResources].[EmployeePayHistory] b
  WHERE a.BusinessEntityID = b.BusinessEntityID) + 10 as NewRate
,2 as PayFrequency
,getdate() as ModifiedDate
FROM [HumanResources].[EmployeeDepartmentHistory] a
WHERE a.DepartmentID = 6
and StartDate = (SELECT MAX(c.StartDate) 
                 FROM HumanResources.EmployeeDepartmentHistory c 
                 WHERE c.BusinessEntityID = a.BusinessEntityID)

• A primeira subconsulta recupera a última taxa salarial de um funcionário antes de adicionar os 10 adicionais.
• A segunda subconsulta obtém o último registro de salário do funcionário.
• Por último, o resultado do SELECT é inserido no EmployeePayHistory tabela.

Em outras instruções T-SQL

Declarações de variáveis ​​ou instruções SET em procedimentos armazenados e funções

DECLARE @maxTransId int = (SELECT MAX(TransactionID) 
                           FROM Production.TransactionHistory)

DECLARE @maxTransId int

SET @maxTransId = (SELECT MAX(TransactionID) 
                   FROM Production.TransactionHistory)

Em Expressões Condicionais

IF EXISTS(SELECT [Name] FROM sys.tables where [Name] = 'MyVendors')
BEGIN
     DROP TABLE MyVendors
END

IF (SELECT count(*) FROM MyVendors) > 0
BEGIN
    -- insert code here
    
END

Faça subconsultas SQL com comparação ou operadores lógicos

Usando operadores de comparação

USE [AdventureWorks]
GO
SELECT b.LastName, b.FirstName, b.MiddleName, a.JobTitle, a.BusinessEntityID
FROM HumanResources.Employee a
INNER JOIN Person.Person b on a.BusinessEntityID = b.BusinessEntityID
INNER JOIN HumanResources.EmployeeDepartmentHistory c on a.BusinessEntityID      
                                                       = c.BusinessEntityID
WHERE c.DepartmentID = 6
  and StartDate = (SELECT d.StartDate 
                   FROM HumanResources.EmployeeDepartmentHistory d 
                   WHERE d.BusinessEntityID = a.BusinessEntityID)

Usando operadores lógicos

Usando EXISTS ou NOT EXISTS

IF EXISTS(SELECT name FROM sys.tables where name = 'Token')
BEGIN      
   DROP TABLE Token
END

Usando IN ou NOT IN

-- From the product inventory, extract the products that are available 
-- (Quantity >0) 
-- except for products from Vendor 1676, and introduce a price cut for the --- whole month of June 2020. 
-- Insert the results in product price history.
USE [AdventureWorks]
GO
INSERT INTO [Production].[ProductListPriceHistory]
           ([ProductID]
           ,[StartDate]
           ,[EndDate]
           ,[ListPrice]
           ,[ModifiedDate])
SELECT
 a.ProductID
,'06/01/2020' as StartDate
,'06/30/2020' as EndDate
,a.ListPrice - 2 as ReducedListPrice
,getdate() as ModifiedDate
FROM [Production].[ProductListPriceHistory] a
WHERE a.StartDate = (SELECT MAX(StartDate) 
                     FROM Production.ProductListPriceHistory 
                     WHERE ProductID = a.ProductID)
AND a.ProductID IN (SELECT ProductID 
                    FROM Production.ProductInventory 
                    WHERE Quantity > 0)
AND a.ProductID NOT IN (SELECT ProductID 
                        FROM [Purchasing].[ProductVendor] 
                        WHERE BusinessEntityID = 1676

Aninhamento de subconsultas SQL

-- List down the names of employees who are also customers.
USE [AdventureWorks]
GO
SELECT
LastName
,FirstName
,MiddleName
FROM Person.Person
WHERE BusinessEntityID IN (SELECT BusinessEntityID 
                           FROM Sales.Customer
                           WHERE BusinessEntityID IN 
                                (SELECT BusinessEntityID 
                                 FROM HumanResources.Employee))

As subconsultas SQL são ruins para o desempenho?

Exemplo 1

USE [AdventureWorks]
GO
SELECT Name
FROM Production.Product
WHERE ListPrice = SELECT ListPrice
                  FROM Production.Product
                  WHERE Name = 'Touring End Caps')

USE [AdventureWorks]
GO
SELECT Prd1.Name
FROM Production.Product AS Prd1
INNER JOIN Production.Product AS Prd2 ON (Prd1.ListPrice = Prd2.ListPrice)
WHERE Prd2.Name = 'Touring End Caps'

1. Clique com o botão direito do mouse no plano de execução da instrução usando a subconsulta.
2. Selecione Salvar plano de execução como .
3. Nomeie o arquivo subquery-execution-plan.sqlplan .
4. Vá para o plano de execução da instrução usando uma junção e clique com o botão direito do mouse.
5. Selecione Comparar plano de exibição .
6. Selecione o nome do arquivo que você salvou em #3.

• As linhas e os custos estimados são os mesmos.
• QueryPlanHash também é o mesmo, o que significa que eles têm planos de execução semelhantes.

• O tamanho do plano de cache é maior usando a junção do que usando a subconsulta
• A CPU e o tempo de compilação (em ms), incluindo a memória em KB, usada para analisar, vincular e otimizar o plano de execução é maior usando a junção do que a subconsulta
• O tempo de CPU e o tempo decorrido (em ms) para executar o plano são um pouco maiores usando a junção versus a subconsulta

Exemplo 2

-- Subquery example
USE [AdventureWorks]
GO
SELECT [SalesOrderID], [OrderDate], [ShipDate], [CustomerID]
FROM Sales.SalesOrderHeader
WHERE [CustomerID] IN (SELECT c.[CustomerID] FROM Sales.Customer c
                       INNER JOIN Person.Person p ON c.PersonID =  
                                                p.BusinessEntityID
                       WHERE p.PersonType='SC')

-- Join example
USE [AdventureWorks]
GO
SELECT o.[SalesOrderID], o.[OrderDate], o.[ShipDate], o.[CustomerID]
FROM Sales.SalesOrderHeader o
INNER JOIN Sales.Customer c on o.CustomerID = c.CustomerID
INNER JOIN Person.Person p ON c.PersonID = p.BusinessEntityID
WHERE p.PersonType = 'SC'

• O destaque em rosa no plano de execução revela operações semelhantes para ambas as consultas. Como a consulta interna usa uma junção em vez de aninhar subconsultas, isso é bastante compreensível.
• Os custos estimados do operador e da subárvore são os mesmos.

• Primeiro, a compilação demorou mais quando usamos junções. Você pode verificar isso em Compile CPU e Compile Time. No entanto, a consulta com uma subconsulta levou uma memória de compilação mais alta em KB.
• Então, o QueryPlanHash de ambas as consultas é diferente, o que significa que elas têm um plano de execução diferente.
• Por fim, o tempo decorrido e o tempo de CPU para executar o plano são mais rápidos usando a junção do que usar uma subconsulta.

Subconsulta vs. Conclusão do desempenho de participação

Avisos comuns no uso de subconsultas SQL

O problema da resolução de nomes de colunas

USE [AdventureWorks]
GO
-- Create the table for our demonstration based on Vendors
CREATE TABLE Purchasing.MyVendors
(
BusinessEntity_id int,
AccountNumber nvarchar(15),
Name nvarchar(50)
)
GO
-- Populate some data to our new table
INSERT INTO Purchasing.MyVendors
SELECT BusinessEntityID, AccountNumber, Name 
FROM Purchasing.Vendor
WHERE BusinessEntityID IN (SELECT BusinessEntityID 
                           FROM Purchasing.ProductVendor)
AND BusinessEntityID like '14%'
GO

SELECT b.Name, b.ListPrice, a.BusinessEntityID
FROM Purchasing.ProductVendor a
INNER JOIN Production.Product b on a.ProductID = b.ProductID
WHERE a.BusinessEntityID IN (SELECT BusinessEntityID 
                             FROM Purchasing.MyVendors)

Mas você pode se perguntar: por que diabos o SQL Server permitiu executar a consulta com sucesso em primeiro lugar?

Tudo bem, está claro, não podemos fazer nada sobre o padrão, mas como podemos evitar erros?

• Primeiro, prefixe os nomes das colunas com o nome da tabela ou use um alias. Em outras palavras, evite nomes de tabela sem prefixo ou sem alias.
• Segundo, tenha uma nomenclatura consistente de colunas. Evite ter ambos BusinessEntityID e BusinessEntity_id , por exemplo.

NULLs malucos

SELECT b.Name, b.ListPrice, a.BusinessEntityID
FROM Purchasing.ProductVendor a
INNER JOIN Production.Product b on a.ProductID = b.ProductID
WHERE a.BusinessEntityID NOT IN (SELECT c.BusinessEntity_id 
                                 FROM Purchasing.MyVendors c)

• Faça com que a coluna da tabela não permita NULLs se os dados não deveriam ser assim.
• Ou adicione o column_name IS NOT NULL para o seu ONDE cláusula. No nosso caso, a subconsulta é a seguinte:

SELECT b.Name, b.ListPrice, a.BusinessEntityID
FROM Purchasing.ProductVendor a
INNER JOIN Production.Product b on a.ProductID = b.ProductID
WHERE a.BusinessEntityID NOT IN (SELECT c.BusinessEntity_id 
                                 FROM Purchasing.MyVendors c
                                 WHERE c.BusinessEntity_id IS NOT NULL)

Recomendações

• é uma consulta dentro de uma consulta.
• está entre parênteses.
• pode substituir uma expressão em qualquer lugar.
• pode ser usado em SELECT , INSERIR , ATUALIZAÇÃO , EXCLUIR, ou outras instruções T-SQL.
• pode ser independente ou correlacionado.
• gera valores únicos, múltiplos ou de tabela.
• funciona em operadores de comparação como =, <>,>, <,>=, <=e operadores lógicos como IN /NÃO DENTRO e EXISTE /NÃO EXISTE .
• não é ruim ou mau. Pode ter um desempenho melhor ou pior do que JOIN s dependendo de uma situação. Portanto, siga meu conselho e sempre verifique os planos de execução.
• pode ter um comportamento desagradável em NULL s quando usado com NOT IN , e quando uma coluna não é explicitamente identificada com uma tabela ou alias de tabela.

• Discussão de subconsultas da Microsoft.
• IN (Transact-SQL)
• EXISTE (Transact-SQL)
• TODOS (Transact-SQL)
• ALGUNS | ANY (Transact-SQL)
• Operadores de comparação