Contando DISTINCT sobre múltiples columnas

¿Hay una mejor manera de hacer una consulta como esta:

SELECT COUNT(*) 
FROM (SELECT DISTINCT DocumentId, DocumentSessionId
      FROM DocumentOutputItems) AS internalQuery

Necesito contar el número de elementos distintos de esta tabla, pero el elemento distintivo está sobre dos columnas.

Mi consulta funciona bien, pero me preguntaba si puedo obtener el resultado final usando solo una consulta (sin usar una subconsulta)

Si está intentando mejorar el rendimiento, puede intentar crear una columna calculada persistente en un valor hash o concatenado de las dos columnas.

Una vez que persiste, siempre que la columna sea determinista y esté utilizando configuraciones de base de datos "sanas", se puede indexar y / o se pueden crear estadísticas en ella.

Creo que un recuento distinto de la columna calculada sería equivalente a su consulta.

Editar: alterado de la consulta de suma de comprobación poco confiable, descubrí una forma de hacer esto (en SQL Server 2005) que funciona bastante bien para mí y puedo usar tantas columnas como necesite (agregándolas a la función CHECKSUM ()). La función REVERSE () convierte los ints en varchars para hacer que el distintivo sea más confiable

SELECT COUNT(DISTINCT (CHECKSUM(DocumentId,DocumentSessionId)) + CHECKSUM(REVERSE(DocumentId),REVERSE(DocumentSessionId)) )
FROM DocumentOutPutItems

¿De qué se trata su consulta existente que no le gusta? Si te preocupa queDISTINCT en dos columnas no devuelva solo las permutaciones únicas, ¿por qué no probarlo?

Ciertamente funciona como es de esperar en Oracle.

SQL> select distinct deptno, job from emp
  2  order by deptno, job
  3  /

    DEPTNO JOB
---------- ---------
        10 CLERK
        10 MANAGER
        10 PRESIDENT
        20 ANALYST
        20 CLERK
        20 MANAGER
        30 CLERK
        30 MANAGER
        30 SALESMAN

9 rows selected.


SQL> select count(*) from (
  2  select distinct deptno, job from emp
  3  )
  4  /

  COUNT(*)
----------
         9

SQL>

editar

Bajé por un callejón sin salida con análisis, pero la respuesta fue deprimentemente obvia ...

SQL> select count(distinct concat(deptno,job)) from emp
  2  /

COUNT(DISTINCTCONCAT(DEPTNO,JOB))
---------------------------------
                                9

SQL>

editar 2

Teniendo en cuenta los siguientes datos, la solución de concatenación proporcionada anteriormente contará erróneamente:

col1  col2
----  ----
A     AA
AA    A

Entonces incluiremos un separador ...

select col1 + '*' + col2 from t23
/

Obviamente, el separador elegido debe ser un carácter, o conjunto de caracteres, que nunca puede aparecer en ninguna columna.

Para ejecutar como una sola consulta, concatene las columnas, luego obtenga el recuento distinto de instancias de la cadena concatenada.

SELECT count(DISTINCT concat(DocumentId, DocumentSessionId)) FROM DocumentOutputItems;

En MySQL puede hacer lo mismo sin el paso de concatenación de la siguiente manera:

SELECT count(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems;

Esta característica se menciona en la documentación de MySQL:

http://dev.mysql.com/doc/refman/5.7/en/group-by-functions.html#function_count-distinct

¿Qué tal algo como:

seleccione cuenta (*)
de
  (seleccione cuenta (*) cnt
   de DocumentOutputItems
   grupo por DocumentId, DocumentSessionId) t1

Probablemente solo haga lo mismo que usted, pero evita el DISTINCT.

Aquí hay una versión más corta sin la subselección:

SELECT COUNT(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems

Funciona bien en MySQL, y creo que al optimizador le resulta más fácil entenderlo.

Editar: Aparentemente leí mal MSSQL y MySQL, lo siento, pero tal vez ayude de todos modos.

Muchas (¿la mayoría?) Bases de datos SQL pueden funcionar con tuplas como valores, por lo que puede hacer lo siguiente: SELECT COUNT(DISTINCT (DocumentId, DocumentSessionId)) FROM DocumentOutputItems; si su base de datos no lo admite, puede simularse según la sugerencia de @ oncel-umut-turer de CHECKSUM u otra función escalar que brinde una buena singularidad. por ej COUNT(DISTINCT CONCAT(DocumentId, ':', DocumentSessionId)).

Un uso relacionado de tuplas es realizar INconsultas como: SELECT * FROM DocumentOutputItems WHERE (DocumentId, DocumentSessionId) in (('a', '1'), ('b', '2'));

No hay nada malo con su consulta, pero también puede hacerlo de esta manera:

WITH internalQuery (Amount)
AS
(
    SELECT (0)
      FROM DocumentOutputItems
  GROUP BY DocumentId, DocumentSessionId
)
SELECT COUNT(*) AS NumberOfDistinctRows
  FROM internalQuery

Espero que esto funcione, estoy escribiendo en prima vista

SELECT COUNT(*) 
FROM DocumentOutputItems 
GROUP BY DocumentId, DocumentSessionId

He usado este enfoque y me ha funcionado.

SELECT COUNT(DISTINCT DocumentID || DocumentSessionId) 
FROM  DocumentOutputItems

Para mi caso, proporciona el resultado correcto.

si solo tuviera un campo para "DISTINCT", podría usar:

SELECT COUNT(DISTINCT DocumentId) 
FROM DocumentOutputItems

y eso devuelve el mismo plan de consulta que el original, según lo probado con SET SHOWPLAN_ALL ON. Sin embargo, está utilizando dos campos para que pueda probar algo loco como:

    SELECT COUNT(DISTINCT convert(varchar(15),DocumentId)+'|~|'+convert(varchar(15), DocumentSessionId)) 
    FROM DocumentOutputItems

pero tendrá problemas si hay NULL involucrados. Solo me quedaría con la consulta original.

Encontré esto cuando busqué en Google mi propio problema, descubrí que si cuentas los objetos DISTINCT, obtienes el número correcto devuelto (estoy usando MySQL)

SELECT COUNT(DISTINCT DocumentID) AS Count1, 
  COUNT(DISTINCT DocumentSessionId) AS Count2
  FROM DocumentOutputItems

Desearía que MS SQL también pudiera hacer algo como COUNT (DISTINCT A, B). Pero no puede.

Al principio, la respuesta de JayTee me pareció una solución, pero después de algunas pruebas CHECKSUM () no pudo crear valores únicos. Un ejemplo rápido es que tanto CHECKSUM (31,467,519) como CHECKSUM (69,1120,823) dan la misma respuesta que es 55.

Luego investigué un poco y descubrí que Microsoft NO recomienda usar CHECKSUM para fines de detección de cambios. En algunos foros algunos sugirieron usar

SELECT COUNT(DISTINCT CHECKSUM(value1, value2, ..., valueN) + CHECKSUM(valueN, value(N-1), ..., value1))

pero esto tampoco es reconfortante.

Puede usar la función HASHBYTES () como se sugiere en el enigma CHECKSUM de TSQL . Sin embargo, esto también tiene una pequeña posibilidad de no devolver resultados únicos.

Sugeriría usar

SELECT COUNT(DISTINCT CAST(DocumentId AS VARCHAR)+'-'+CAST(DocumentSessionId AS VARCHAR)) FROM DocumentOutputItems

Qué tal esto,

Select DocumentId, DocumentSessionId, count(*) as c 
from DocumentOutputItems 
group by DocumentId, DocumentSessionId;

Esto nos dará el recuento de todas las combinaciones posibles de DocumentId y DocumentSessionId

Esto funciona para mi. En oráculo:

SELECT SUM(DECODE(COUNT(*),1,1,1))
FROM DocumentOutputItems GROUP BY DocumentId, DocumentSessionId;

En jpql:

SELECT SUM(CASE WHEN COUNT(i)=1 THEN 1 ELSE 1 END)
FROM DocumentOutputItems i GROUP BY i.DocumentId, i.DocumentSessionId;

Tenía una pregunta similar, pero la consulta que tuve fue una subconsulta con los datos de comparación en la consulta principal. algo como:

Select code, id, title, name 
(select count(distinct col1) from mytable where code = a.code and length(title) >0)
from mytable a
group by code, id, title, name
--needs distinct over col2 as well as col1

Ignorando las complejidades de esto, me di cuenta de que no podía obtener el valor de un código en la subconsulta con la subconsulta doble descrita en la pregunta original

Select count(1) from (select distinct col1, col2 from mytable where code = a.code...)
--this doesn't work because the sub-query doesn't know what "a" is

Así que eventualmente descubrí que podía hacer trampa y combinar las columnas:

Select count(distinct(col1 || col2)) from mytable where code = a.code...

Esto es lo que terminó funcionando

Si está trabajando con tipos de datos de longitud fija, puede enviarlos binarypara hacerlo de manera muy fácil y rápida. Asumiendo DocumentIdy DocumentSessionIdson ambos ints, y por lo tanto son 4 bytes de longitud ...

SELECT COUNT(DISTINCT CAST(DocumentId as binary(4)) + CAST(DocumentSessionId as binary(4)))
FROM DocumentOutputItems

Mi problema específico me obligaba a dividir un SUMporCOUNT combinación distinta de varias claves foráneas y un campo de fecha, agrupando por otra clave foránea y ocasionalmente filtrando por ciertos valores o claves. La tabla es muy grande y el uso de una subconsulta aumentó drásticamente el tiempo de consulta. Y debido a la complejidad, las estadísticas simplemente no eran una opción viable. La CHECKSUMsolución también fue demasiado lenta en su conversión, particularmente como resultado de los diversos tipos de datos, y no podía arriesgar su falta de confiabilidad.

Sin embargo, el uso de la solución anterior prácticamente no aumentó el tiempo de consulta (en comparación con el uso de simplemente el SUM), ¡y debería ser completamente confiable! Debería poder ayudar a otros en una situación similar, así que lo estoy publicando aquí.

Simplemente puede usar la función Count dos veces.

En este caso, sería:

SELECT COUNT (DISTINCT DocumentId), COUNT (DISTINCT DocumentSessionId) 
FROM DocumentOutputItems

Este código utiliza distintos parámetros en 2 y proporciona el recuento de la cantidad de filas específicas para esos valores distintos. Me funcionó en MySQL como un encanto.

select DISTINCT DocumentId as i,  DocumentSessionId as s , count(*) 
from DocumentOutputItems   
group by i ,s;