Cómo funciona NTILE() en SQL Server

En SQL Server, el NTILE() La función le permite distribuir las filas en una partición ordenada en un número específico de grupos. Los grupos están numerados, comenzando en 1. Para cada fila, NTILE() devuelve el número del grupo al que pertenece la fila.

Simplemente proporcione la cantidad de grupos que desea al llamar a la función.

Sintaxis

La sintaxis es así:

NTILE (integer_expression) OVER ( [  ] < order_by_clause > )

expresión_entera es una expresión entera positiva que especifica el número de grupos en los que se debe dividir cada partición. Puede ser de tipo int o bigint .

es opcional. Divide el conjunto de resultados producido por FROM cláusula en particiones a las que se aplica la función.

es requerido. Determina el orden en que NTILE() los valores se asignan a las filas en una partición. Un entero no puede representar una columna cuando se utiliza en una función de clasificación.

Ejemplo 1:uso básico

Aquí hay un ejemplo básico que muestra cómo funciona esta función:

SELECT 
  Player,
  Score,
  NTILE(4) OVER (ORDER BY Score DESC) 'NTILE'
FROM Scoreboard;

Resultado:

+----------+---------+---------+
| Player   | Score   | NTILE   |
|----------+---------+---------|
| Bart     | 2010    | 1       |
| Burns    | 1270    | 1       |
| Meg      | 1030    | 2       |
| Marge    | 990     | 2       |
| Lisa     | 710     | 3       |
| Ned      | 666     | 3       |
| Apu      | 350     | 4       |
| Homer    | 1       | 4       |
+----------+---------+---------+

En este caso hay 8 resultados y el valor que proporciono a NTILE() es 4, por lo que los valores se distribuyen uniformemente en 4 grupos.

Ejemplo 2:cambiar el valor NTILE

Esto es lo que sucede si cambio el NTILE() valor a 3.

SELECT 
  Player,
  Score,
  NTILE(3) OVER (ORDER BY Score DESC) 'NTILE'
FROM Scoreboard;

Resultado:

+----------+---------+---------+
| Player   | Score   | NTILE   |
|----------+---------+---------|
| Bart     | 2010    | 1       |
| Burns    | 1270    | 1       |
| Meg      | 1030    | 1       |
| Marge    | 990     | 2       |
| Lisa     | 710     | 2       |
| Ned      | 666     | 2       |
| Apu      | 350     | 3       |
| Homer    | 1       | 3       |
+----------+---------+---------+

Los resultados se distribuyen en 3 grupos. Como era de esperar, el último grupo termina con solo 2 filas (en comparación con las 3 de los otros grupos).

Ejemplo 3:cambia el orden

Cambiar el orden entre ascendente y descendente generalmente resultará en el NTILE() valores que se aplican a diferentes filas.

SELECT 
  Player,
  Score,
  NTILE(4) OVER (ORDER BY Score DESC) 'NTILE Descending',
  NTILE(4) OVER (ORDER BY Score ASC) 'NTILE Ascending'
FROM Scoreboard
ORDER BY Score DESC;

Resultado:

+----------+---------+--------------------+-------------------+
| Player   | Score   | NTILE Descending   | NTILE Ascending   |
|----------+---------+--------------------+-------------------|
| Bart     | 2010    | 1                  | 4                 |
| Burns    | 1270    | 1                  | 4                 |
| Meg      | 1030    | 2                  | 3                 |
| Marge    | 990     | 2                  | 3                 |
| Lisa     | 710     | 3                  | 2                 |
| Ned      | 666     | 3                  | 2                 |
| Apu      | 350     | 4                  | 1                 |
| Homer    | 1       | 4                  | 1                 |
+----------+---------+--------------------+-------------------+

Sin embargo, esto dependerá de cuántas filas haya en el conjunto de resultados frente a la cantidad de NTILE. Obviamente, si el NTILE() valor es 1, entonces no habrá diferencia.

SELECT 
  Player,
  Score,
  NTILE(1) OVER (ORDER BY Score DESC) 'NTILE Descending',
  NTILE(1) OVER (ORDER BY Score ASC) 'NTILE Ascending'
FROM Scoreboard
ORDER BY Score DESC;

Resultado:

+----------+---------+--------------------+-------------------+
| Player   | Score   | NTILE Descending   | NTILE Ascending   |
|----------+---------+--------------------+-------------------|
| Bart     | 2010    | 1                  | 1                 |
| Burns    | 1270    | 1                  | 1                 |
| Meg      | 1030    | 1                  | 1                 |
| Marge    | 990     | 1                  | 1                 |
| Lisa     | 710     | 1                  | 1                 |
| Ned      | 666     | 1                  | 1                 |
| Apu      | 350     | 1                  | 1                 |
| Homer    | 1       | 1                  | 1                 |
+----------+---------+--------------------+-------------------+

Ocurrirá lo mismo si el conjunto de resultados contiene solo una fila, independientemente del NTILE() valor:

SELECT 
  Player,
  Score,
  NTILE(4) OVER (ORDER BY Score DESC) 'NTILE Descending',
  NTILE(4) OVER (ORDER BY Score ASC) 'NTILE Ascending'
FROM Scoreboard
WHERE Score > 2000
ORDER BY Score DESC;

Resultado:

+----------+---------+--------------------+-------------------+
| Player   | Score   | NTILE Descending   | NTILE Ascending   |
|----------+---------+--------------------+-------------------|
| Bart     | 2010    | 1                  | 1                 |
+----------+---------+--------------------+-------------------+

Ejemplo 4:Particiones

Puedes usar la PARTITION BY cláusula para dividir los resultados en particiones. Cuando haces esto, NTILE() se aplica contra cada partición.

Ejemplo:

SELECT 
  TeamName,
  Player,
  Score,
  NTILE(2) OVER (PARTITION BY TeamName ORDER BY Score ASC) 'NTILE'
FROM Scoreboard s
INNER JOIN Team t
ON t.TeamId = s.TeamId;

Resultado:

+------------+----------+---------+-------------------+
| TeamName   | Player   | Score   | NTILE             |
|------------+----------+---------+-------------------|
| Mongrels   | Apu      | 350     | 1                 |
| Mongrels   | Ned      | 666     | 1                 |
| Mongrels   | Meg      | 1030    | 2                 |
| Mongrels   | Burns    | 1270    | 2                 |
| Simpsons   | Homer    | 1       | 1                 |
| Simpsons   | Lisa     | 710     | 1                 |
| Simpsons   | Marge    | 990     | 2                 |
| Simpsons   | Bart     | 2010    | 2                 |
+------------+----------+---------+-------------------+