Cuente dónde dos o más columnas seguidas están sobre un cierto valor [baloncesto, doble doble, triple doble]

Juego un juego de baloncesto que permite generar sus estadísticas como un archivo de base de datos, para poder calcular estadísticas que no se implementan en el juego. Hasta ahora no he tenido problemas para calcular las estadísticas que quería, pero ahora me he encontrado con un problema: contar el número de dobles dobles y / o triples dobles que un jugador hizo durante la temporada a partir de las estadísticas de su juego.

La definición de doble doble y triple doble es la siguiente:

Doble doble:

Un doble doble se define como una actuación en la cual un jugador acumula un total de dos dígitos en dos de las cinco categorías estadísticas: puntos, rebotes, asistencias, robos y tiros bloqueados en un juego.

Triple doble:

Un triple-doble se define como una actuación en la que un jugador acumula un número total de dos dígitos en tres de las cinco categorías estadísticas (puntos, rebotes, asistencias, robos y tiros bloqueados) en un juego.

Cuádruple-doble (agregado para aclaración)

Un cuádruple-doble se define como una actuación en la que un jugador acumula un número total de dos dígitos en cuatro de cinco categorías estadísticas (puntos, rebotes, asistencias, robos y tiros bloqueados) en un juego.

La tabla "PlayerGameStats" almacena estadísticas de cada juego que juega un jugador y tiene el siguiente aspecto:

CREATE TABLE PlayerGameStats AS SELECT * FROM ( VALUES
  ( 1, 1,  1, 'Nuggets',    'Cavaliers',  6,  8,  2, 2,  0 ),
  ( 2, 1,  2, 'Nuggets',     'Clippers', 15,  7,  0, 1,  3 ),
  ( 3, 1,  6, 'Nuggets', 'Trailblazers', 11, 11,  1, 2,  1 ),
  ( 4, 1, 10, 'Nuggets',    'Mavericks',  8, 10,  2, 2, 12 ),
  ( 5, 1, 11, 'Nuggets',       'Knicks', 23, 12,  1, 0,  0 ),
  ( 6, 1, 12, 'Nuggets',         'Jazz',  8,  8, 11, 1,  0 ),
  ( 7, 1, 13, 'Nuggets',         'Suns',  7, 11,  2, 2,  1 ),
  ( 8, 1, 14, 'Nuggets',        'Kings', 10, 15,  0, 3,  1 ),
  ( 9, 1, 15, 'Nuggets',        'Kings',  9,  7,  5, 0,  4 ),
  (10, 1, 17, 'Nuggets',      'Thunder', 13, 10, 10, 1,  0 )
) AS t(id,player_id,seasonday,team,opponent,points,rebounds,assists,steals,blocks);

El resultado que quiero lograr se ve así:

| player_id |    team | doubleDoubles | tripleDoubles |
|-----------|---------|---------------|---------------|
|         1 | Nuggets |             4 |             1 |

La única solución que encontré hasta ahora es tan horrible que me hace vomitar ...; o) ... Se ve así:

SELECT 
  player_id,
  team,
  SUM(CASE WHEN(points >= 10 AND rebounds >= 10) OR
               (points >= 10 AND assists  >= 10) OR
               (points >= 10 AND steals   >= 10) 
                THEN 1 
                ELSE 0 
      END) AS doubleDoubles
FROM PlayerGameStats
GROUP BY player_id

... y ahora probablemente también estás vomitando (o riéndote fuerte) después de leer esto. Ni siquiera escribí todo lo que se necesitaría para obtener todas las combinaciones dobles dobles, y omití la declaración del caso para los dobles triples porque es aún más ridículo.

¿Hay una mejor manera de hacer esto? Ya sea con la estructura de tabla que tengo o con una nueva estructura de tabla (podría escribir un script para convertir la tabla).

Puedo usar MySQL 5.5 o PostgreSQL 9.2.

Aquí hay un enlace a SqlFiddle con datos de ejemplo y mi horrible solución que publiqué anteriormente: http://sqlfiddle.com/#!2/af6101/3

Tenga en cuenta que no estoy realmente interesado en los dobles cuádruples (ver arriba) ya que no ocurren en el juego que juego hasta donde yo sé, pero sería una ventaja si la consulta se puede expandir fácilmente sin tener que volver a escribir en la cuenta para dobles cuádruples.

No sé si esta es la mejor manera. Primero hice una selección para averiguar si una estadística es de dos dígitos y asignarle un 1 si lo es. Resumió todos esos para descubrir el número total de dobles dígitos por juego. A partir de ahí, resumir todos los dobles y triples. Parece funcionar

select a.player_id, 
a.team, 
sum(case when a.doubles = 2 then 1 else 0 end) as doubleDoubles, 
sum(case when a.doubles = 3 then 1 else 0 end) as tripleDoubles
from
(select *, 
(case when points > 9 then 1 else 0 end) +
(case when rebounds > 9 then 1 else 0 end) +
(case when assists > 9 then 1 else 0 end) +
(case when steals > 9 then 1 else 0 end) +
(case when blocks > 9 then 1 else 0  end) as Doubles
from PlayerGameStats) a
group by a.player_id, a.team

Pruebe esto (funcionó para mí en MySQL 5.5):

SELECT 
  player_id,
  team,
  SUM(
    (   (points   >= 10)
      + (rebounds >= 10)
      + (assists  >= 10)
      + (steals   >= 10)
      + (blocks   >= 10) 
    ) = 2
  ) double_doubles,
  SUM(
    (   (points   >= 10)
      + (rebounds >= 10)
      + (assists  >= 10)
      + (steals   >= 10)
      + (blocks   >= 10) 
    ) = 3
  ) triple_doubles
FROM PlayerGameStats
GROUP BY player_id, team

O incluso más corto, arrancando descaradamente el código de JChao de su respuesta, pero sacando las CASEdeclaraciones innecesarias ya que boolean expr se evalúa en {1,0} cuando {True, False}:

select a.player_id, 
a.team, 
sum(a.doubles = 2) as doubleDoubles, 
sum(a.doubles = 3) as tripleDoubles
from
(select *, 
(points > 9) +
(rebounds > 9) +
(assists > 9) +
(steals > 9) +
(blocks > 9) as Doubles
from PlayerGameStats) a
group by a.player_id, a.team

Según los comentarios, el código anterior no se ejecutará en PostgreSQL ya que no le gusta hacer boolean + boolean. Aún no me gusta CASE. Aquí hay una salida en PostgreSQL (9.3), enviando a int:

select a.player_id, 
a.team, 
sum((a.doubles = 2)::int) as doubleDoubles, 
sum((a.doubles = 3)::int) as tripleDoubles
from
(select *, 
(points > 9)::int +
(rebounds > 9)::int +
(assists > 9)::int +
(steals > 9)::int +
(blocks > 9)::int as Doubles
from PlayerGameStats) a
group by a.player_id, a.team

Aquí hay otra versión del problema.

A mi modo de ver, básicamente estás trabajando con datos pivotados para el problema actual, por lo que lo primero que debes hacer es desconectarlo. Lamentablemente, PostgreSQL no proporciona buenas herramientas para hacerlo, por lo que sin entrar en la generación dinámica de SQL en PL / PgSQL, al menos podemos hacer:

SELECT player_id, seasonday, 'points' AS scoretype, points AS score FROM playergamestats
UNION ALL
SELECT player_id, seasonday, 'rebounds' AS scoretype, rebounds FROM playergamestats
UNION ALL
SELECT player_id, seasonday, 'assists' AS scoretype, assists FROM playergamestats
UNION ALL
SELECT player_id, seasonday, 'steals' AS scoretype, steals FROM playergamestats
UNION ALL
SELECT player_id, seasonday, 'blocks' AS scoretype, blocks FROM playergamestats

Esto pone los datos en una forma más maleable, aunque seguramente no es bonita. Aquí supongo que (player_id, seasonday) es suficiente para identificar de forma única a los jugadores, es decir, la ID del jugador es única en todos los equipos. Si no es así, deberá incluir suficiente información adicional para proporcionar una clave única.

Con esos datos no divididos ahora es posible filtrarlos y agregarlos de maneras útiles, como:

SELECT
  player_id,
  count(CASE WHEN doubles = 2 THEN 1 END) AS doubledoubles,
  count(CASE WHEN doubles = 3 THEN 1 END) AS tripledoubles
FROM (
    SELECT
      player_id, seasonday, count(*) AS doubles
    FROM
    (
        SELECT player_id, seasonday, 'points' AS scoretype, points AS score FROM playergamestats
        UNION ALL
        SELECT player_id, seasonday, 'rebounds' AS scoretype, rebounds FROM playergamestats
        UNION ALL
        SELECT player_id, seasonday, 'assists' AS scoretype, assists FROM playergamestats
        UNION ALL
        SELECT player_id, seasonday, 'steals' AS scoretype, steals FROM playergamestats
        UNION ALL
        SELECT player_id, seasonday, 'blocks' AS scoretype, blocks FROM playergamestats
    ) stats
    WHERE score >= 10
    GROUP BY player_id, seasonday
) doublestats
GROUP BY player_id;

Esto está lejos de ser bonito, y probablemente no sea tan rápido. Sin embargo, es mantenible y requiere cambios mínimos para manejar nuevos tipos de estadísticas, nuevas columnas, etc.

Por lo tanto, es más un "oye, ¿pensaste?" Que una sugerencia seria. El objetivo era modelar el SQL para que se correspondiera con la declaración del problema lo más directamente posible, en lugar de hacerlo rápido.

Esto se hizo mucho más fácil gracias al uso de inserciones sanas de valores múltiples y las citas ANSI en su SQL orientado a MySQL. Gracias; Es bueno no ver backticks por una vez. Todo lo que tuve que cambiar fue la generación de claves sintéticas.

Lo que @Joshua muestra para MySQL también funciona en Postgres. Booleanlos valores se pueden convertir integery sumar. Sin embargo, el elenco debe ser explícito. Hace para código muy corto:

SELECT player_id, team
     , count(doubles = 2 OR NULL) AS doubledoubles
     , count(doubles = 3 OR NULL) AS tripledoubles
FROM  (
   SELECT player_id, team,
          (points   > 9)::int +
          (rebounds > 9)::int +
          (assists  > 9)::int +
          (steals   > 9)::int +
          (blocks   > 9)::int AS doubles
   FROM playergamestats
   ) a
GROUP  BY 1, 2;

• También utilizando un método más corto para contar los dobles en el exterior SELECT.
  Detalles en esta respuesta relacionada.

Sin embargo, CASEaunque es más detallado, generalmente es un poco más rápido. Y más portátil, si eso importa:

SELECT player_id, team
     , count(doubles = 2 OR NULL) AS doubledoubles
     , count(doubles = 3 OR NULL) AS tripledoubles
FROM  (
   SELECT player_id, team,
          CASE WHEN points   > 9 THEN 1 ELSE 0 END +
          CASE WHEN rebounds > 9 THEN 1 ELSE 0 END +
          CASE WHEN assists  > 9 THEN 1 ELSE 0 END +
          CASE WHEN steals   > 9 THEN 1 ELSE 0 END +
          CASE WHEN blocks   > 9 THEN 1 ELSE 0 END AS doubles
   FROM playergamestats
   ) a
GROUP  BY 1, 2;

SQL Fiddle.

Usando división entera y conversión binaria

SELECT player_id
     , team
     , SUM(CASE WHEN Doubles = 2 THEN 1 ELSE 0 END) DoubleDouble
     , SUM(CASE WHEN Doubles = 3 THEN 1 ELSE 0 END) TripleDouble
FROM   (SELECT player_id
             , team
             , (BINARY (points DIV 10) > 0)
             + (BINARY (rebounds DIV 10) > 0)
             + (BINARY (assists DIV 10) > 0)
             + (BINARY (steals DIV 10) > 0)
             + (BINARY (blocks DIV 10) > 0)
             AS Doubles
        FROM   PlayerGameStats) d
GROUP BY player_id, team

Solo quiero dejar una variación de la versión de @Craig Ringers aquí que encontré por accidente, tal vez sea útil para alguien en el futuro.

En lugar de múltiples UNION ALL, usa unnest y array. Fuente de inspiración: /programming/1128737/unpivot-and-postgresql

SELECT
  player_id,
  count(CASE WHEN doubles = 2 THEN 1 END) AS doubledoubles,
  count(CASE WHEN doubles = 3 THEN 1 END) AS tripledoubles
FROM (
    SELECT
      player_id, seasonday, count(*) AS doubles
    FROM
    (
        SELECT 
          player_id, 
          seasonday,
          unnest(array['Points', 'Rebounds', 'Assists', 'Steals', 'Blocks']) AS scoretype,
          unnest(array[Points, Rebounds, Assists, Steals, Blocks]) AS score
        FROM PlayerGameStats
    ) stats
    WHERE score >= 10
    GROUP BY player_id, seasonday
) doublestats
GROUP BY player_id;

SQL Fiddle: http://sqlfiddle.com/#!12/4980b/3