Birden çok sütun üzerinde DISTINCT sayma

Böyle bir sorgu yapmanın daha iyi bir yolu var mı:

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

Bu tablodan farklı öğe sayısını saymak gerekiyor ama farklı iki sütun üzerinde.

Benim sorgu iyi çalışıyor ama ben sadece bir sorgu kullanarak (bir alt sorgu kullanmadan) nihai sonuç alabilir miyim merak ediyordum

Performansı artırmaya çalışıyorsanız, iki sütunun karma veya bitmiş değeri üzerinde kalıcı bir hesaplanmış sütun oluşturmayı deneyebilirsiniz.

Devam edildikten sonra, sütun deterministik olduğu ve "aklı başında" veritabanı ayarlarını kullandığınız takdirde, dizine eklenebilir ve / veya üzerinde istatistik oluşturulabilir.

Hesaplanan sütunun ayrı bir sayısının sorgunuza eşdeğer olacağına inanıyorum.

Düzenleme: Güvenilir az sağlama-yalnızca sorgudan değiştirildi benim için oldukça iyi çalışır ve (onları ekleyerek) (Ben bunları ekleyerek CHECKSUM () işlevi). REVERSE () işlevi, farklıları daha güvenilir hale getirmek için girişleri varcharlara dönüştürür

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

Mevcut sorgunuzda beğenmediğiniz şey nedir? Eğer DISTINCTiki sütun arasında sadece benzersiz permütasyonlar dönmüyor endişe varsa neden denemek?

Kesinlikle Oracle'da beklediğiniz gibi çalışır.

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>

Düzenle

Analitik ile kör bir yola indim ama cevap iç karartıcı bir şekilde belliydi ...

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

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

SQL>

düzenleme 2

Aşağıdaki veriler göz önüne alındığında, yukarıda sağlanan birleştirme çözümü yanlış sayılır:

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

Bir ayırıcı ekleyelim ...

select col1 + '*' + col2 from t23
/

Açıkçası, seçilen ayırıcı, hiçbir zaman iki sütunda görünmeyecek bir karakter veya karakter kümesi olmalıdır.

Tek bir sorgu olarak çalıştırmak için sütunları birleştirin, ardından birleştirilmiş dizenin farklı örnek sayısını alın.

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

MySQL'de aynı işlemi birleştirme adımı olmadan aşağıdaki gibi yapabilirsiniz:

SELECT count(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems;

Bu özellik MySQL belgelerinde belirtilmiştir:

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

Nasıl bir şey hakkında:

sayı seç (*)
itibaren
  (sayımı seçin (*) cnt
   DocumentOutputItems tarafından
   DocumentId, DocumentSessionId tarafından gruplandır) t1

Muhtemelen zaten seninle aynı şeyi yapar ama DISTINCT'den kaçınır.

Alt seçim olmadan daha kısa bir sürüm:

SELECT COUNT(DISTINCT DocumentId, DocumentSessionId) FROM DocumentOutputItems

MySQL'de iyi çalışıyor ve optimize edicinin bunu anlamak için daha kolay bir zaman olduğunu düşünüyorum.

Düzenleme: Görünüşe göre MSSQL ve MySQL yanlış - bunun için üzgünüm, ama belki yine de yardımcı olur.

Birçok (en çok?) SQL veritabanı değer gibi tuples ile çalışabilir, böylece şunları yapabilirsiniz: SELECT COUNT(DISTINCT (DocumentId, DocumentSessionId)) FROM DocumentOutputItems; Veritabanınız bunu desteklemiyorsa, @ oncel-umut-turer'in CHECKSUM önerisine veya iyi bir benzersizlik sağlayan diğer skaler fonksiyonlarına göre simüle edilebilir örn COUNT(DISTINCT CONCAT(DocumentId, ':', DocumentSessionId)).

Tuples ile ilgili bir kullanım aşağıdaki INgibi sorguları gerçekleştirmektir : SELECT * FROM DocumentOutputItems WHERE (DocumentId, DocumentSessionId) in (('a', '1'), ('b', '2'));

Sorgunuzla ilgili yanlış bir şey yok, ancak bunu şu şekilde de yapabilirsiniz:

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

Umarım bu çalışır prima vista üzerine yazıyorum

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

Bu yaklaşımı kullandım ve benim için çalıştı.

SELECT COUNT(DISTINCT DocumentID || DocumentSessionId) 
FROM  DocumentOutputItems

Benim durumum için, doğru sonuç sağlar.

"DISTINCT" için yalnızca bir alanınız varsa, şunu kullanabilirsiniz:

SELECT COUNT(DISTINCT DocumentId) 
FROM DocumentOutputItems

SET SHOWPLAN_ALL ON ile test edildiği gibi, orijinaliyle aynı sorgu planını döndürür. Ancak iki alan kullanıyorsunuz, böylece deli gibi bir şey deneyebilirsiniz:

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

ancak NULL'lar söz konusuysa sorun yaşarsınız. Ben sadece orijinal sorguyla devam ederdim.

Kendi sorunum için Google'da aradığımda bunu buldum, DISTINCT nesnelerini sayarsanız, doğru sayıyı döndürdüğünüzü buldum (MySQL kullanıyorum)

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

Keşke MS SQL de COUNT (DISTINCT A, B) gibi bir şey yapabilir. Ama olamaz.

Bazı testler CHECKSUM () benzersiz değerler oluşturamadı sonra ilk başta JayTee cevap bana bir çözüm gibi görünüyordu. Bunun hızlı bir örneği hem CHECKSUM (31,467,519) hem de CHECKSUM (69,1120,823) 55 ile aynı cevabı vermektedir.

Sonra biraz araştırma yaptım ve Microsoft'un değişiklik algılama amacıyla CHECKSUM kullanılmasını önermediğini gördüm. Bazı forumlarda bazıları

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

ama bu da şaşırtıcı değil.

HASHBYTES () işlevini TSQL CHECKSUM bilmecinde önerildiği gibi kullanabilirsiniz . Bununla birlikte, bunun benzersiz sonuçlar döndürmeme şansı da düşüktür.

Kullanmanızı öneririm

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

Buna ne dersin,

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

Bu bize tüm DocumentId ve DocumentSessionId kombinasyonlarının sayısını verir

Benim için çalışıyor. Kehanette:

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

Jpql dilinde:

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

Ben benzer bir soru vardı ama ben sorgu ana sorgu karşılaştırma verileri ile bir alt sorgu oldu. gibi bir şey:

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

Bunun karmaşıklığını göz ardı ederek, orijinal soruda açıklanan çift alt sorgu ile alt sorgu içine a.code değerini alamadım fark ettim

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

Sonunda hile yapabileceğimi ve sütunları birleştirebileceğimi anladım:

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

Sonuçta işte bu

Sabit uzunlukta veri tipleri ile çalışıyorsanız, bunu binaryçok kolay ve çok hızlı bir şekilde yapabilirsiniz. Varsayım DocumentIdve DocumentSessionIdher ikisi de ints ve bu nedenle 4 bayt uzunluğunda ...

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

Benim spesifik problem bölmek için beni gerekli SUMtarafından COUNTbaşka yabancı anahtar ile gruplama ve bazen belirli değerleri veya tuşlar ile filtreleme, çeşitli yabancı anahtarların farklı kombinasyon ve bir tarih alanı. Tablo çok büyük ve bir alt sorgu kullanmak sorgu süresini önemli ölçüde artırdı. Ve karmaşıklık nedeniyle, istatistikler basitçe uygulanabilir bir seçenek değildi. CHECKSUMSolüsyon özellikle çeşitli veri türlerinin bir sonucu olarak, onun dönüşümde çok yavaş da oldu ve onun güvenilmezliğini riskini göze alamazdım.

Bununla birlikte, yukarıdaki çözümün kullanılması sorgu süresinde neredeyse hiç artış göstermemiştir (sadece ile karşılaştırıldığında SUM) ve tamamen güvenilir olmalıdır! Benzer bir durumda başkalarına yardımcı olmalı, bu yüzden buraya gönderiyorum.

Sadece Sayım İşlevini İki Kez kullanabilirsiniz.

Bu durumda şöyle olur:

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

Bu kod, farklı 2 parametre kullanır ve bu farklı değerler satır sayısına özgü satır sayısı sağlar. MySQL'de benim için bir cazibe gibi çalıştı.

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