T-SQL : Impacto en performance por no utilizar expresiones SARGS

Uno de los ANTI-PATRONES (malas prácticas) de performance más frecuente es no utilizar consultas que tengan una expresión SARGS, lo cual impactará de forma notoria en la performance de nuestros procesos.

En este artículo te voy a contar que son las expresiones SARGS y veremos varios ejemplos de estos anti-patrones con su respectivo impacto en la performance.

Que es una consulta SARGABLE

Sargable es una palabra que está compuesta por tres palabras : búsqueda, argumento y capaz.

En otras palabras, SARGable se define como “En las bases de datos relacionales, se dice que una condición (o predicado) en una consulta es sargable si el motor DBMS puede aprovechar un índice para acelerar la ejecución de la consulta.

El término se deriva de una contracción de Search ARGument ABLE

Las ventajas de usar consultas SARGS son:

  1. Usar los índices de forma eficiente
  2. Consumir la menor cantidad de recursos de nuestro servidor (CPU, IOPS, RAM)
  3. Mejorar los tiempos de respuesta de nuestros procesos / consultas.

Ejemplos

Para mis ejemplos utilizaré la base de datos AdventureWorks la cual podras descargar del siguiente link

https://github.com/Microsoft/sql-server-samples/releases/tag/adventureworks

Funciones en los WHERE

Usar funciones en los campos de los WHERE hará que nuestra consulta no sea SARG compatible y por ende no se usen los índices de forma eficiente.

Veamos los siguientes ejemplos

SELECT * FROM Person.Person
WHERE LastName = 'Miller'
SELECT * FROM Person.Person
WHERE LEFT(LastName,4) = 'Mill'
SELECT * FROM Person.Person
WHERE upper(LastName) = 'MILLER'

Ahora vamos a analizar los planes de ejecución de cada una de nuestras consultas

Consulta 1
Consulta 2
Consulta 3

Como se puede observar la consulta 1 que si es SARGS usa de forma eficiente el indice (Index Seek), pero en cambio la consulta 2 y 3 como no son SARGS no lo están usando de forma eficiente (Index Scan)

Veamos que significa esto en numeros de costos de recursos.

ConsultaCosto Total Query PlanCosto CPUCosto I/O
10.280,01350.263
20.400.03630.365
30.390.03630.361

Hagamos ahora una prueba de stress de performance con nuestras 3 consultas para ver que sucede, para eso voy a utilizar la herramienta gratuita SQLQueryStress con cada una de las consultas usando 50 hilos y 50 iteraciones

Como se puede observar en las pruebas de stress también vemos impacto en los tiempos del proceso y consumos de recursos.

Funciones de fecha

Ahora vamos a ver otro ejemplo más donde usamos funciones en los WHERE pero con fechas.

Para eso veremos estas dos consultas las cuales retornan los mismos resultados.

SELECT SalesOrderID,OrderDate   
 FROM Sales.SalesOrderHeader H
 WHERE OrderDate > = '20110101'
 AND OrderDate < '20120101'
SELECT SalesOrderID,OrderDate   
 FROM Sales.SalesOrderHeader H
 WHERE YEAR(OrderDate)  = '2011'

Ahora vamos a observar los planes de ejecución donde veremos que la consulta 1 utiliza el índice de forma eficiente mientras la consulta 2 no lo hace

La siguiente tabla muestra los costos y consumos de la consulta 1 y 2 en donde se puede observar un consumo mucho mayor en la consulta 2 que en la 1, esta tabla es más grande que la del ejemplo anterior.

ConsultaCosto Total query PlanCosto CPUCosto I/O
10.00720.00190.0053
20.0980.0340.060

Uso de ISNULL en el WHERE

En este otro ejemplo veremos el uso de la función ISNULL en el WHERE y ver que sucede con SARG

Para este ejemplo primero vamos a crear un índice nuevo en nuestra tabla Person.Person

DROP INDEX IF EXISTS IX1 ON Person.Person
CREATE INDEX IX1 ON  Person.Person(MIDDLENAME)

Ahora veremos estas dos consultas que retornan los mismos resultados, pero en la primera usamos el ISNULL en el WHERE y en la segunda no.

SELECT BusinessEntityID,MiddleName 
FROM Person.Person
WHERE ISNULL(MiddleName,'A')='A' 
SELECT BusinessEntityID,MiddleName  
FROM Person.Person
WHERE (MiddleName IS NULL OR MiddleName ='A')  

Observemos ahora cada plan de ejecución y sus costos

Consulta 1
Consulta2

ConsultaCosto Total Query PlanCosto CPUCosto I/O
10.0520.0220.030
20.0270.0200.016

Aquí también podemos observar que la consulta 1 no es SARG y por ende hace un scan del indice siendo mas costoso que la consulta 2

Operadores en los campos del WHERE

Otra de las situaciones que hacen que una consulta no sea SARG es que se utilicen operadores en los campos del WHERE.

Vamos a analizarlo con ejemplos como los casos anteriores.

Para este ejemplo usaremos la tabla Sales.SalesOrderDetail de nuestra base de datos de ejemplo.

Primero creamos un índice como el siguiente:

DROP INDEX IF EXISTS IX_2 ON
 [Sales].[SalesOrderDetail] 
 CREATE NONCLUSTERED INDEX IX_2 ON
 [Sales].[SalesOrderDetail] (
 [UnitPriceDiscount]
 )
 INCLUDE (
  [ProductID],
  [UnitPrice],
  [OrderQty]
 );

Luego vamos a probar las siguientes consultas y observar sus planes de ejecución / consumos

SELECT  
  [ProductID],
  [UnitPrice],
  [OrderQty]
 FROM  Sales.SalesOrderDetail
 WHERE UnitPriceDiscount + 0.10 >= 0.30 -- no es SARG compatible
 GROUP BY 
 [ProductID],
 [UnitPrice],
 [OrderQty]
SELECT  
  [ProductID],
  [UnitPrice],
  [OrderQty]
 FROM  Sales.SalesOrderDetail
 WHERE UnitPriceDiscount >= 0.20
 GROUP BY 
 [ProductID],
 [UnitPrice],
 [OrderQty]
ConsultaCosto Total Query PlanCosto CPUCosto I/O
10.660.1380.52
20.0250.00960.0156

Como se puede observar la primer consulta al no se SARG compatible tiene un mayor costo por usar el índice en modo Scan,

JOINS y SARG

Los JOINS no se quedan atras tambien de estas prácticas, si aplicamos comandos no SARG en los ON vamos a ver un impacto en la performance.

Veamos las dos siguientes consultas donde ambas dan los mismos resultados pero en una no usamos SARG compatible y por ende cambiará nuestro plan de ejecución.

SELECT p.ProductID,
  p.Name AS ProductName,
  c.Name AS Category,
  s.Name AS SubCategory
 FROM Production.Product AS p
 inner JOIN Production.ProductSubcategory AS s
  ON p.ProductSubcategoryID = s.ProductSubcategoryID
 INNER JOIN Production.ProductCategory AS c
  ON s.ProductCategoryID + 10 = c.ProductCategoryID + 10
SELECT p.ProductID,
  p.Name AS ProductName,
  c.Name AS Category,
  s.Name AS SubCategory
 FROM Production.Product AS p
 inner JOIN Production.ProductSubcategory AS s
  ON p.ProductSubcategoryID = s.ProductSubcategoryID
 INNER JOIN Production.ProductCategory AS c
  ON s.ProductCategoryID  = c.ProductCategoryID 
ConsultaCosto Total Query PlanCosto CPUCosto I/O
10.0650.04200.0212
20.0530.02980.0212

Conclusiones finales

La utilización de los anti-patrones que vimos los cuales hacen que una consulta TSQL puede ser SARGS compatible tiene impactos muy negativos en nuestros consumos de recursos y performance en general.

En mis años de experiencia veo de forma recurrente estas malas prácticas en el código TSQL las cuales sugiero siempre corregir en mis clientes.

Recuerden que más allá de los tiempos y consumos, si estamos en Azure por ejemplo vamos a estar gastando más dinero por no tener optimizados nuestro código.

Rating: 1 out of 5.

SQL Server: LEFT JOIN vs NOT EXISTS (Performance)

SQL Server: LEFT JOIN vs NOT EXISTS (Performance)


En mis años como consultor he visto en muchas ocasiones que los programadores usan los JOIN para hacer algún tipo de búsqueda del tipo: Traer los clientes que no tienen ventas o cosas similares.


El JOIN como concepto esta mas pensado para buscar datos entre tablas y presentarlos, por ejemplo si tenemos una tabla facturas y otra clientes entonces es lógico que si necesitamos datos de clientes necesitemos hacer algún tipo de JOIN


En este post veremos el impacto de performance que tiene usar un LEFT JOIN para buscar por ejemplo los clientes que no tienen ordenes en lugar de usar un NOT EXISTS.


Veamos el siguiente ejemplo donde las dos consultas van a retornar los mismos resultados.

USE ADVENTUREWORKS2017 
GO

SELECT * FROM PRODUCTION.PRODUCT P
WHERE NOT EXISTS 
(
 SELECT * FROM SALES.SALESORDERDETAIL D
 WHERE P.PRODUCTID = D.PRODUCTID 
)

SELECT P.* FROM PRODUCTION.PRODUCT P
LEFT JOIN SALES.SALESORDERDETAIL D
ON P.PRODUCTID = D.PRODUCTID 
WHERE D.PRODUCTID IS NULL
En ambas consultas vamos a observar que los resultados son idénticos, retornando 238 registros.

Ahora bien vamos a ver que sucede con sus respectivos planes de ejecución

Podemos observar que en el caso del NOT EXISTS hay una operación eficiente en del índice pero en el LEFT JOIN vemos un SCAN
El costo del primer plan es de 0.10 y el segundo de 0.68 (casi 7 veces mas)

%d bloggers like this: