MySQL'de ROW_NUMBER ()

MySQL'de SQL Server işlevini çoğaltmanın güzel bir yolu var mı ROW_NUMBER()?

Örneğin:

SELECT 
    col1, col2, 
    ROW_NUMBER() OVER (PARTITION BY col1, col2 ORDER BY col3 DESC) AS intRow
FROM Table1

Sonra, örneğin, her çift intRowiçin en yüksek col3olan tek bir satır elde etmek için 1 ile sınırlamak için bir koşul ekleyebilirim (col1, col2).

Her (col1, col2) çifti için tek en yüksek col3 satır istiyorum.

Bu grup halinde bir maksimum , en sık sorulan SQL sorularından biri (kolay olması gerektiği gibi görünüyor, ama aslında öyle değil).

Sık sık bir boş-katılma için tombul:

SELECT t0.col3
FROM table AS t0
LEFT JOIN table AS t1 ON t0.col1=t1.col1 AND t0.col2=t1.col2 AND t1.col3>t0.col3
WHERE t1.col1 IS NULL;

“Eşleşen col1, col2 ile daha yüksek bir col3'e sahip başka satır bulunmayan tablodaki satırları alın.” (Bunu fark edeceksiniz ve birden fazla satır aynı col1, col2, col3'e sahipse, grup-maksimum diğer çözümlerin çoğu birden çok satır döndürecektir. Bu bir sorunsa, bazı son işlemlere ihtiyacınız olabilir.)

MySQL'de sıralama işlevi yoktur. Alabileceğiniz en yakın değişken kullanmaktır:

SELECT t.*, 
       @rownum := @rownum + 1 AS rank
  FROM YOUR_TABLE t, 
       (SELECT @rownum := 0) r

Peki bu benim durumumda nasıl çalışır? Ben col1 ve col2 her biri için iki değişken gerekir? Col1 değiştiğinde Col2 bir şekilde sıfırlanması gerekir ..?

Evet. Oracle olsaydı, bir sonraki değerde zirve yapmak için LEAD işlevini kullanabilirsiniz. Neyse ki, Quassnoi MySQL'de uygulamanız gerekenlerin mantığını kapsar .

Her zaman bu kalıbı takip ediyorum. Bu tablo verildiğinde:

+------+------+
|    i |    j |
+------+------+
|    1 |   11 |
|    1 |   12 |
|    1 |   13 |
|    2 |   21 |
|    2 |   22 |
|    2 |   23 |
|    3 |   31 |
|    3 |   32 |
|    3 |   33 |
|    4 |   14 |
+------+------+

Bu sonucu alabilirsiniz:

+------+------+------------+
|    i |    j | row_number |
+------+------+------------+
|    1 |   11 |          1 |
|    1 |   12 |          2 |
|    1 |   13 |          3 |
|    2 |   21 |          1 |
|    2 |   22 |          2 |
|    2 |   23 |          3 |
|    3 |   31 |          1 |
|    3 |   32 |          2 |
|    3 |   33 |          3 |
|    4 |   14 |          1 |
+------+------+------------+

Tanımlanmış herhangi bir değişkene ihtiyaç duymayan bu sorguyu çalıştırarak:

SELECT a.i, a.j, count(*) as row_number FROM test a
JOIN test b ON a.i = b.i AND a.j >= b.j
GROUP BY a.i, a.j

Umarım yardımcı olur!

SELECT 
    @i:=@i+1 AS iterator, 
    t.*
FROM 
    tablename AS t,
    (SELECT @i:=0) AS foo

Bu makaleye göz atın, SQL ROW_NUMBER () 'in bir bölümle MySQL içinde nasıl taklit edileceğini gösterir. Aynı senaryoya bir WordPress Uygulamasında rastladım. ROW_NUMBER () gerekli ve orada değildi.

http://www.explodybits.com/2011/11/mysql-row-number/

Makaledeki örnek, alana göre tek bir bölüm kullanmaktır. Ek alanlara göre bölümlemek için şöyle bir şey yapabilirsiniz:

  SELECT  @row_num := IF(@prev_value=concat_ws('',t.col1,t.col2),@row_num+1,1) AS RowNumber
         ,t.col1 
         ,t.col2
         ,t.Col3
         ,t.col4
         ,@prev_value := concat_ws('',t.col1,t.col2)
    FROM table1 t,
         (SELECT @row_num := 1) x,
         (SELECT @prev_value := '') y
   ORDER BY t.col1,t.col2,t.col3,t.col4 

Concat_ws kullanımı null değerlerini işler. Bunu int, date ve varchar kullanarak 3 alana karşı test ettim. Bu yardımcı olur umarım. Bu sorguyu bozup açıklarken makaleye göz atın.

Gönderen MySQL 8.0.0ve üzeri özgün olarak pencereli işlevleri kullanabilirsiniz.

1.4 MySQL 8.0'daki Yenilikler :

Pencere fonksiyonları.

MySQL artık bir sorgudaki her satır için o satırla ilgili satırları kullanarak bir hesaplama yapan pencere işlevlerini desteklemektedir. Bunlar RANK (), LAG () ve NTILE () gibi işlevleri içerir. Ayrıca, mevcut birkaç toplama işlevi artık pencere işlevleri olarak kullanılabilir; örneğin, SUM () ve AVG ().

ROW_NUMBER () over_cuseuse :

Bölümündeki geçerli satırın sayısını döndürür. Satır numaraları 1 ile bölüm satırı sayısı arasında değişir.

ORDER BY, satırların numaralandırılma sırasını etkiler. ORDER BY olmadan, satır numaralandırma belirsizdir.

Demo:

CREATE TABLE Table1(
  id INT AUTO_INCREMENT PRIMARY KEY, col1 INT,col2 INT, col3 TEXT);

INSERT INTO Table1(col1, col2, col3)
VALUES (1,1,'a'),(1,1,'b'),(1,1,'c'),
       (2,1,'x'),(2,1,'y'),(2,2,'z');

SELECT 
    col1, col2,col3,
    ROW_NUMBER() OVER (PARTITION BY col1, col2 ORDER BY col3 DESC) AS intRow
FROM Table1;

DBFiddle Demosu

Ayrıca sorgu kodunda küçük değişikliklerle Mosty Mostacho'nun çözümüne oy verirdim:

SELECT a.i, a.j, (
    SELECT count(*) from test b where a.j >= b.j AND a.i = b.i
) AS row_number FROM test a

Hangi aynı sonucu verecektir:

+------+------+------------+
|    i |    j | row_number |
+------+------+------------+
|    1 |   11 |          1 |
|    1 |   12 |          2 |
|    1 |   13 |          3 |
|    2 |   21 |          1 |
|    2 |   22 |          2 |
|    2 |   23 |          3 |
|    3 |   31 |          1 |
|    3 |   32 |          2 |
|    3 |   33 |          3 |
|    4 |   14 |          1 |
+------+------+------------+

tablo için:

+------+------+
|    i |    j |
+------+------+
|    1 |   11 |
|    1 |   12 |
|    1 |   13 |
|    2 |   21 |
|    2 |   22 |
|    2 |   23 |
|    3 |   31 |
|    3 |   32 |
|    3 |   33 |
|    4 |   14 |
+------+------+

Sorgunun JOIN ve GROUP BY kullanmadığı tek farkla, bunun yerine iç içe seçime dayanarak.

Ben bir fonksiyon tanımlamak:

delimiter $$
DROP FUNCTION IF EXISTS `getFakeId`$$
CREATE FUNCTION `getFakeId`() RETURNS int(11)
    DETERMINISTIC
begin
return if(@fakeId, @fakeId:=@fakeId+1, @fakeId:=1);
end$$

o zaman yapabilirdim:

select getFakeId() as id, t.* from table t, (select @fakeId:=0) as t2;

Artık görünümlerde bulunamayan bir alt sorgunuz yok.

mysql'de row_number için sorgu

set @row_number=0;
select (@row_number := @row_number +1) as num,id,name from sbs

MySQL'de böyle bir işlev yoktur rownum, row_num()ancak yol aşağıdaki gibidir:

select 
      @s:=@s+1 serial_no, 
      tbl.* 
from my_table tbl, (select @s:=0) as s;

En iyi şekilde çalıştığım çözüm şöyle bir alt sorgu kullanmaktı:

SELECT 
    col1, col2, 
    (
        SELECT COUNT(*) 
        FROM Table1
        WHERE col1 = t1.col1
        AND col2 = t1.col2
        AND col3 > t1.col3
    ) AS intRow
FROM Table1 t1

PARTITION BY sütunları sadece '=' ile karşılaştırılır ve AND ile ayrılır. ORDER BY sütunları '<' veya '>' ile karşılaştırılır ve OR ile ayrılır.

Biraz pahalı olsa bile çok esnek buldum.

Rownumber işlevi taklit edilemez. Beklediğiniz sonuçları alabilirsiniz, ancak büyük olasılıkla bir aşamada hayal kırıklığına uğrayacaksınız. MySQL belgeleri şöyle diyor:

SELECT gibi diğer ifadeler için beklediğiniz sonuçları alabilirsiniz, ancak bu garanti edilmez. Aşağıdaki ifadede, MySQL'in önce @a'yı sonra ikinci bir atama yapacağını düşünebilirsiniz: SELECT @a, @a: = @ a + 1, ...; Bununla birlikte, kullanıcı değişkenlerini içeren ifadeler için değerlendirme sırası tanımlanmamıştır.

Saygılar Georgi.

MariaDB 10.2, RANK (), ROW_NUMBER () ve diğer birçok şey dahil "Pencere İşlevleri" ni uyguluyor:

https://mariadb.com/kb/en/mariadb/window-functions/

Bu ay Percona Live'daki bir konuşmaya dayanarak, oldukça iyi optimize edilmişler.

Sözdizimi, Soru'daki kodla aynıdır.

"PARTITION BY" bölümünü kapsayan basit bir cevap görmüyorum, işte benim:

SELECT
    *
FROM (
    select
        CASE WHEN @partitionBy_1 = l THEN @row_number:=@row_number+1 ELSE @row_number:=1 END AS i
        , @partitionBy_1:=l AS p
        , t.*
    from (
        select @row_number:=0,@partitionBy_1:=null
    ) as x
    cross join (
        select 1 as n, 'a' as l
        union all
        select 1 as n, 'b' as l    
        union all
        select 2 as n, 'b' as l    
        union all
        select 2 as n, 'a' as l
        union all
        select 3 as n, 'a' as l    
        union all    
        select 3 as n, 'b' as l    
    ) as t
    ORDER BY l, n
) AS X
where i > 1

• ORDER BY deyimi ROW_NUMBER ihtiyacınızı yansıtmalıdır. Bu nedenle zaten açık bir sınırlama vardır: Bu formda aynı anda birkaç ROW_NUMBER "öykünme" olamaz.
• "Hesaplanan sütun" un sırası önemlidir . Eğer mysql bu sütunu başka bir sırayla hesaplarsanız, çalışmayabilir.

• Bu basit örnekte sadece bir tane koydum ama birkaç "PARTITION BY" parçasına sahip olabilirsiniz

      CASE WHEN @partitionBy_1 = part1 AND @partitionBy_2 = part2 [...] THEN @row_number:=@row_number+1 ELSE @row_number:=1 END AS i
      , @partitionBy_1:=part1 AS P1
      , @partitionBy_2:=part2 AS P2
      [...] 
  FROM (
      SELECT @row_number:=0,@partitionBy_1:=null,@partitionBy_2:=null[...]
  ) as x

Biraz geç ama cevap arayan birine de yardımcı olabilir ...

Satırlar / satır_sayısı örneği - herhangi bir SQL'de kullanılabilecek özyinelemeli sorgu arasında:

WITH data(row_num, some_val) AS 
(
 SELECT 1 row_num, 1 some_val FROM any_table --dual in Oracle
  UNION ALL
 SELECT row_num+1, some_val+row_num FROM data WHERE row_num < 20 -- any number
)
SELECT * FROM data
 WHERE row_num BETWEEN 5 AND 10
/

ROW_NUM    SOME_VAL
-------------------
5           11
6           16
7           22
8           29
9           37
10          46

Bu, ROW_NUMBER () AND PARTITION BY tarafından sağlanan işlevselliklerin MySQL'de elde edilmesini sağlar

SELECT  @row_num := IF(@prev_value=GENDER,@row_num+1,1) AS RowNumber
       FirstName, 
       Age,
       Gender,
       @prev_value := GENDER
  FROM Person,
      (SELECT @row_num := 1) x,
      (SELECT @prev_value := '') y
  ORDER BY Gender, Age DESC

Ayrıca biraz geç ama bugün aynı ihtiyacı vardı, bu yüzden Google'da arama yaptım ve son olarak burada Pinal Dave'in makalesinde bulunan basit bir genel yaklaşım http://blog.sqlauthority.com/2014/03/09/mysql-reset-row -sayısı-için-her grup-bölme-ile sıralı-numarası /

Paul'ün orijinal sorusuna odaklanmak istedim (bu da benim sorunumdu), bu yüzden çözümümü çalışan bir örnek olarak özetledim.

Çünkü yeni bir grubun başlatılıp başlatılmadığını belirlemek için yineleme sırasında bir SET değişkeni oluşturacağım.

SELECT col1, col2, col3 FROM (
  SELECT col1, col2, col3,
         @n := CASE WHEN @v = MAKE_SET(3, col1, col2)
                    THEN @n + 1 -- if we are in the same group
                    ELSE 1 -- next group starts so we reset the counter
                END AS row_number,
         @v := MAKE_SET(3, col1, col2) -- we store the current value for next iteration
    FROM Table1, (SELECT @n := 0, @v := NULL) r -- helper table for iteration with startup values
   ORDER BY col1, col2, col3 DESC -- because we want the row with maximum value
) x WHERE row_number = 1 -- and here we select exactly the wanted row from each group

3, MAKE_SET'in ilk parametresinde SET'te (3 = 1 | 2) her iki değeri istediğim anlamına gelir. Tabii ki grupları inşa eden iki veya daha fazla sütunumuz yoksa MAKE_SET işlemini ortadan kaldırabiliriz. İnşaat tamamen aynı. Bu benim için gerektiği gibi çalışıyor. Açık gösteri için Pinal Dave'e çok teşekkürler.

Bu da bir çözüm olabilir:

SET @row_number = 0;

SELECT 
    (@row_number:=@row_number + 1) AS num, firstName, lastName
FROM
    employees

MySQL, 8.0 ve sonraki sürümlerden beri ROW_NUMBER () yöntemini destekledi .

MySQL 8.0 veya üstünü kullanıyorsanız, ROW_NUMBER () işlevine bakın. Aksi takdirde, ROW_NUMBER () işlevini öykün.

Row_number (), ilk satır için 1'den başlayarak sıranın sıralı sayısını döndüren bir sıralama işlevidir.

eski sürüm için,

SELECT t.*, 
       @rowid := @rowid + 1 AS ROWID
  FROM TABLE t, 
       (SELECT @rowid := 0) dummy;

Önemli: Lütfen MySQL 8+ sürümüne geçmeyi düşünün ve tanımlı ve belgelenmiş ROW_NUMBER () işlevini kullanın ve MySQL'in özelliklerle sınırlı eski bir sürümüne bağlı eski korsanlardan kurtulun

Şimdi bu hacklerden biri:

Burada çoğunlukla sorgu içi değişkenleri kullanan cevaplar / hepsi belgelerin söylediği gerçeğini göz ardı ediyor gibi görünüyor (açıklama):

Yukarıdan aşağıya doğru sırayla değerlendirilmekte olan SELECT listesindeki öğelere güvenmeyin. Bir SELECT öğesinde değişken atama ve bunları başka bir SELECT öğesinde kullanma

Bu nedenle, yanlış cevabı atma riski vardır, çünkü genellikle

select
  (row number variable that uses partition variable),
  (assign partition variable)

Bunlar aşağıdan yukarıya değerlendirilirse, satır numarası çalışmayı durduracaktır (bölüm yok)

Bu nedenle, garantili bir yürütme sırasına sahip bir şey kullanmamız gerekiyor. NE ZAMAN DURUMDA GİRİN:

SELECT
  t.*, 
  @r := CASE 
    WHEN col = @prevcol THEN @r + 1 
    WHEN (@prevcol := col) = null THEN null
    ELSE 1 END AS rn
FROM
  t, 
  (SELECT @r := 0, @prevcol := null) x
ORDER BY col

Anahat ld olarak, prevcol atama sırası önemlidir - biz geçerli satırdan bir değer atamadan önce prevcol geçerli satırın değeri ile karşılaştırılmalıdır (aksi takdirde önceki satırın col değeri değil, geçerli satırların col değeri olurdu) .

Bunun nasıl birbirine uyduğu aşağıda açıklanmıştır:

• İlk NE ZAMAN değerlendirilir. Bu satırın sütunu önceki satırın sütunu ile aynıysa, @r artırılır ve CASE'den döndürülür. Bu dönüş led değerleri @r. MySQL'in bir özelliği, atamanın @r'ye atanan şeyin yeni değerini sonuç satırlarına döndürmesidir.

• Sonuç kümesindeki ilk satır için @prevcol null (alt sorguda null olarak başlatılır), bu nedenle bu yüklem yanlıştır. Bu ilk yüklem ayrıca col her değiştiğinde false değerini döndürür (geçerli satır önceki satırdan farklıdır). Bu, ikinci NE ZAMAN değerlendirilmesine neden olur.

• İkinci WHEN yüklemi her zaman yanlıştır ve yalnızca @prevcol'e yeni bir değer atamak için var olur. Bu satırın col değeri önceki satırın col'sinden farklı olduğu için (bunu biliyoruz çünkü aynı olsaydı, ilk NE ZAMAN kullanılırsa), bir dahaki sefere test için yeni değeri atamamız gerekir. Ödev yapıldığından ve ödevin sonucu null ile karşılaştırıldığından ve null ile eşitlenmiş herhangi bir şey yanlış olduğundan, bu yüklem her zaman yanlıştır. Ancak en azından değerlendirmek, col değerini bu satırdan tutma görevini yaptı, böylece bir sonraki satırın col değerine göre değerlendirilebilir

• İkinci NE ZAMAN yanlış olduğu için, (col) ile bölümlediğimiz sütunun değiştiği durumlarda, numarayı 1'den yeniden başlatarak @r için yeni bir değer veren ELSE'dir.

Bu durumun şu olduğu bir duruma geliyoruz:

SELECT
  t.*, 
  ROW_NUMBER() OVER(PARTITION BY pcol1, pcol2, ... pcolX ORDER BY ocol1, ocol2, ... ocolX) rn
FROM
  t

Genel forma sahiptir:

SELECT
  t.*, 
  @r := CASE 
    WHEN col1 = @pcol1 AND col2 = @pcol2 AND ... AND colX = @pcolX THEN @r + 1 
    WHEN (@pcol1 := pcol1) = null OR (@pcol2 := col2) = null OR ... OR (@pcolX := colX) = null THEN null
    ELSE 1 
  END AS rn
FROM
  t, 
  (SELECT @r := 0, @pcol1 := null, @pcol2 := null, ..., @pcolX := null) x
ORDER BY pcol1, pcol2, ..., pcolX, ocol1, ocol2, ..., ocolX

Dipnotlar:

• Pcol içindeki p "bölüm" anlamına gelir, ocol içindeki o "düzen" anlamına gelir - genel formda görsel karmaşayı azaltmak için değişken adından "prev" i düşürdüm

• Çevresindeki parantezler (@pcolX := colX) = nullönemlidir. Onlar olmadan @pcolX'e null atayacaksınız ve işler artık çalışmıyor

• Önceki sütun karşılaştırmasının çalışması için sonuç kümesinin bölüm sütunları tarafından da sıralanması gerektiği bir uzlaşmadır. Böylece rownumber'ınızı bir sütuna göre sıralayamazsınız, ancak sonuç kümeniz diğerine sıralanabilir. Bunu alt sorgular ile çözebilirsiniz, ancak belgelerin LIMIT kullanılmadığı sürece alt sorgu sırasının göz ardı edilebileceğini ve bu etkinin verim

• Yöntemin işe yaradığını test etmenin ötesine geçmedim, ancak ikinci NE ZAMAN'daki tahminlerin ortadan kaldırılacağı riski varsa (null ile karşılaştırılan herhangi bir şey null / false, öyleyse neden ödevi çalıştırmıyorsunuz) ve yürütülmedi , durur. Bu benim tecrübelerime göre görünmüyor, ancak yorumları memnuniyetle kabul edip makul bir şekilde ortaya çıkabilirse çözüm önereceğim

• @PcolX oluşturan null'ları, @pcolX değişkenlerini oluşturan alt sorguda, sütunlarınızın gerçek türlerine dönüştürmek akıllıca olabilir: select @pcol1 := CAST(null as INT), @pcol2 := CAST(null as DATE)

Bu en sağlam çözüm değildir - ancak yalnızca birkaç farklı değere sahip bir alanda bölümlenmiş bir sıra oluşturmak istiyorsanız, mantıksal olarak istediğiniz kadar çok değişken içeren bir durum kullanmak yararsız olabilir.

Böyle bir şey geçmişte benim için çalıştı:

SELECT t.*, 
   CASE WHEN <partition_field> = @rownum1 := @rownum1 + 1 
     WHEN <partition_field> = @rownum2 := @rownum2 + 1 
     ...
     END AS rank
FROM YOUR_TABLE t, 
   (SELECT @rownum1 := 0) r1, (SELECT @rownum2 := 0) r2
ORDER BY <rank_order_by_field>
;

Umarım mantıklıdır / yardımcı olur!

Bu, birden fazla sütuna sahip olduğumda RowNumber oluşturmam için mükemmel çalışıyor. Bu durumda iki sütun.

SELECT @row_num := IF(@prev_value= concat(`Fk_Business_Unit_Code`,`NetIQ_Job_Code`), @row_num+1, 1) AS RowNumber, 
    `Fk_Business_Unit_Code`,   
    `NetIQ_Job_Code`,  
    `Supervisor_Name`,  
    @prev_value := concat(`Fk_Business_Unit_Code`,`NetIQ_Job_Code`)  
FROM (SELECT DISTINCT `Fk_Business_Unit_Code`,`NetIQ_Job_Code`,`Supervisor_Name`         
      FROM Employee    
      ORDER BY `Fk_Business_Unit_Code`, `NetIQ_Job_Code`, `Supervisor_Name` DESC) z,  
(SELECT @row_num := 1) x,  
(SELECT @prev_value := '') y  
ORDER BY `Fk_Business_Unit_Code`, `NetIQ_Job_Code`,`Supervisor_Name` DESC

set @i = 1;  
INSERT INTO ARG_VALUE_LOOKUP(ARG_VALUE_LOOKUP_ID,ARGUMENT_NAME,VALUE,DESCRIPTION,UPDATE_TIMESTAMP,UPDATE_USER,VER_NBR,OBJ_ID) 
select @i:= @i+1 as ARG_VALUE_LOOKUP_ID,ARGUMENT_NAME,VALUE,DESCRIPTION,CURRENT_TIMESTAMP,'admin',1,UUID() 
FROM TEMP_ARG_VALUE_LOOKUP 
order by ARGUMENT_NAME;

SELECT 
    col1, col2, 
    count(*) as intRow
FROM Table1
GROUP BY col1,col2
ORDER BY col3 desc