Bir Oraclesorgunun bir MySQL limityan tümce içeriyormuş gibi davranmasının bir yolu var mı ?

İçinde MySQLbunu yapabilirim:

select * 
from sometable
order by name
limit 20,10

21. sırayı 30. sıraya çıkarmak için (ilk 20'yi atlayın, sonraki 10'u verin). Satırlar 'dan sonra seçilir order by, bu yüzden gerçekten 20. isimde alfabetik olarak başlar.

In Oracle, insanların bahsettiği tek şey rownumsözde sütun, ancak daha önce değerlendirilir order by, bu şu anlama gelir:

select * 
from sometable
where rownum <= 10
order by name

genellikle istediğim gibi olmayan, sıraya göre sıralı on satırlık rastgele bir set döndürür. Ayrıca bir ofset belirtilmesine izin vermez.

Oracle 12c R1 (12.1) başlanarak, orada olduğu bir madde sınırlayıcı satır . Tanıdık LIMITsözdizimini kullanmaz , ancak daha fazla seçenekle işi daha iyi yapabilir. Sözdiziminin tamamını burada bulabilirsiniz . ( Bu yanıtta bunun Oracle'da dahili olarak nasıl çalıştığı hakkında daha fazla bilgi edinin ).

Orijinal soruyu cevaplamak için sorgu:

SELECT * 
FROM   sometable
ORDER BY name
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

(Önceki Oracle sürümleri için lütfen bu sorudaki diğer yanıtlara bakın)

Örnekler:

Aşağıdaki örnekler, bağlantı çürümesini önleme umuduyla bağlantılı sayfadan alıntılanmıştır .

Kurmak

CREATE TABLE rownum_order_test (
  val  NUMBER
);

INSERT ALL
  INTO rownum_order_test
SELECT level
FROM   dual
CONNECT BY level <= 10;

COMMIT;

Tabloda ne var?

SELECT val
FROM   rownum_order_test
ORDER BY val;

       VAL
----------
         1
         1
         2
         2
         3
         3
         4
         4
         5
         5
         6
         6
         7
         7
         8
         8
         9
         9
        10
        10

20 rows selected.

İlk Nsatırları alın

SELECT val
FROM   rownum_order_test
ORDER BY val DESC
FETCH FIRST 5 ROWS ONLY;

       VAL
----------
        10
        10
         9
         9
         8

5 rows selected.

İlk alın Neğer satırları N^inci satır bağları var, hepsi bağlı satırları almak

SELECT val
FROM   rownum_order_test
ORDER BY val DESC
FETCH FIRST 5 ROWS WITH TIES;

       VAL
----------
        10
        10
         9
         9
         8
         8

6 rows selected.

xSatırların en üst % 'si

SELECT val
FROM   rownum_order_test
ORDER BY val
FETCH FIRST 20 PERCENT ROWS ONLY;

       VAL
----------
         1
         1
         2
         2

4 rows selected.

Ofset kullanma, sayfalandırma için çok yararlı

SELECT val
FROM   rownum_order_test
ORDER BY val
OFFSET 4 ROWS FETCH NEXT 4 ROWS ONLY;

       VAL
----------
         3
         3
         4
         4

4 rows selected.

Ofseti yüzdelerle birleştirebilirsiniz

SELECT val
FROM   rownum_order_test
ORDER BY val
OFFSET 4 ROWS FETCH NEXT 20 PERCENT ROWS ONLY;

       VAL
----------
         3
         3
         4
         4

4 rows selected.

Bunun için bir alt sorgu kullanabilirsiniz

select *
from  
( select * 
  from emp 
  order by sal desc ) 
where ROWNUM <= 5;

Daha fazla bilgi için ROWNUM hakkında ve Oracle / AskTom'daki sonuçları sınırlama konusuna da göz atın .

Güncelleme : Hem alt hem de üst sınırlarla sonucu sınırlamak için işler biraz daha şişirilir

select * from 
( select a.*, ROWNUM rnum from 
  ( <your_query_goes_here, with order by> ) a 
  where ROWNUM <= :MAX_ROW_TO_FETCH )
where rnum  >= :MIN_ROW_TO_FETCH;

(Belirtilen AskTom makalesinden kopyalandı)

Güncelleme 2 : Oracle 12c (12.1) ile başlayarak satırları sınırlamak veya ofsetlerden başlamak için bir sözdizimi vardır.

SELECT * 
FROM   sometable
ORDER BY name
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

Daha fazla örnek için bu cevaba bakınız . İpucu için Krumia'ya teşekkürler.

Aşağıdaki yaklaşımlar için bazı performans testleri yaptım:

Asktom

select * from (
  select a.*, ROWNUM rnum from (
    <select statement with order by clause>
  ) a where rownum <= MAX_ROW
) where rnum >= MIN_ROW

Analitik

select * from (
  <select statement with order by clause>
) where myrow between MIN_ROW and MAX_ROW

Kısa Alternatif

select * from (
  select statement, rownum as RN with order by clause
) where a.rn >= MIN_ROW and a.rn <= MAX_ROW

Sonuçlar

Tabloda 10 milyon kayıt vardı, sıralaması dizine eklenmemiş bir tarih saatindeydi:

• Açıklama planı her üç seçim için de aynı değeri gösterdi (323168)
• Ama kazanan AskTom (analitik takip eden)

İlk 10 satırı seçmek:

• AskTom: 28-30 saniye
• Analitik: 33-37 saniye
• Kısa alternatif: 110-140 saniye

100.000 ve 100.010 arasındaki satırları seçme:

• AskTom: 60 saniye
• Analitik: 100 saniye

9.000.000 ve 9.000.010 arasındaki satırları seçme:

• AskTom: 130 saniye
• Analitik: 150 saniye

Yalnızca bir iç içe sorgu içeren analitik bir çözüm:

SELECT * FROM
(
   SELECT t.*, Row_Number() OVER (ORDER BY name) MyRow FROM sometable t
) 
WHERE MyRow BETWEEN 10 AND 20;

Rank()yerine ikame edilebilir, Row_Number()ancak ad için yinelenen değerler olup olmadığını beklediğinizden daha fazla kayıt döndürebilir.

Oracle 12c'de ( SQL başvurusunda satır sınırlama maddesine bakın ):

SELECT * 
FROM sometable
ORDER BY name
OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;

Oracle'da sipariş içeren sayfalama sorguları gerçekten zor.

Oracle, veritabanının satırı tablodan veya birleştirilmiş görünümler kümesinden seçme sırasını gösteren bir sayı döndüren bir ROWNUM sözde sütunu sağlar.

ROWNUM, birçok insanın başını belaya sokan bir sahte sütundur. Bir ROWNUM değeri bir satıra kalıcı olarak atanmaz (bu yaygın bir yanlış anlamadır). Bir ROWNUM değeri gerçekten atandığında kafa karıştırıcı olabilir. Bir ROWNUM değeri, sorgunun filtre tahminlerini geçtikten sonra , ancak sorgu toplama veya sıralamadan önce bir satıra atanır .

Dahası, bir ROWNUM değeri ancak atandıktan sonra artırılır.

Bu nedenle, aşağıdaki sorgu hiçbir satır döndürmez:

 select * 
 from (select *
       from some_table
       order by some_column)
 where ROWNUM <= 4 and ROWNUM > 1; 

Sorgu sonucunun ilk satırı ROWNUM> 1 yüklemini geçmez, bu nedenle ROWNUM 2'ye artmaz. Bu nedenle, hiçbir ROWNUM değeri 1'den büyük olmaz, sonuç olarak sorgu hiçbir satır döndürmez.

Doğru şekilde tanımlanmış sorgu şöyle görünmelidir:

select *
from (select *, ROWNUM rnum
      from (select *
            from skijump_results
            order by points)
      where ROWNUM <= 4)
where rnum > 1; 

Vertabelo blogundaki makalelerimde sayfalandırma sorguları hakkında daha fazla bilgi edinin :

• Oracle ROWNUM Açıklaması
• En-N ve sayfalama sorguları

SQL Standardı

Bu makalede açıkladığım gibi , SQL: 2008 Standardı SQL sonuç kümesini sınırlamak için aşağıdaki sözdizimini sağlar:

SELECT
    title
FROM
    post
ORDER BY
    id DESC
FETCH FIRST 50 ROWS ONLY

Oracle 11g ve daha eski sürümleri

Sürüm 12c'den önce Top-N kayıtlarını almak için türetilmiş bir tablo ve ROWNUM sözde sütunu kullanmanız gerekiyordu:

SELECT *
FROM (
    SELECT
        title
    FROM
        post
    ORDER BY
        id DESC
)
WHERE ROWNUM <= 50

Daha az SELECT ifadesi. Ayrıca, daha az performans tüketir. Kredi: anibal@upf.br

SELECT *
    FROM   (SELECT t.*,
                   rownum AS rn
            FROM   shhospede t) a
    WHERE  a.rn >= in_first
    AND    a.rn <= in_first;

Kabul edilen cevabın bir uzantısı olarak Oracle dahili olarak ROW_NUMBER/RANKfonksiyonları kullanır . OFFSET FETCHsözdizimi bir sözdizimi şekeri.

DBMS_UTILITY.EXPAND_SQL_TEXTProsedür kullanılarak gözlemlenebilir :

Numune hazırlanıyor:

CREATE TABLE rownum_order_test (
  val  NUMBER
);

INSERT ALL
  INTO rownum_order_test
SELECT level
FROM   dual
CONNECT BY level <= 10;
COMMIT;

Sorgu:

SELECT val
FROM   rownum_order_test
ORDER BY val DESC
FETCH FIRST 5 ROWS ONLY;

düzenli:

SELECT "A1"."VAL" "VAL" 
FROM  (SELECT "A2"."VAL" "VAL","A2"."VAL" "rowlimit_$_0",
               ROW_NUMBER() OVER ( ORDER BY "A2"."VAL" DESC ) "rowlimit_$$_rownumber" 
      FROM "ROWNUM_ORDER_TEST" "A2") "A1" 
WHERE "A1"."rowlimit_$$_rownumber"<=5 ORDER BY "A1"."rowlimit_$_0" DESC;

db <> keman demosu

Genişletilmiş SQL metni getiriliyor:

declare
  x VARCHAR2(1000);
begin
 dbms_utility.expand_sql_text(
        input_sql_text => '
          SELECT val
          FROM   rownum_order_test
          ORDER BY val DESC
          FETCH FIRST 5 ROWS ONLY',
        output_sql_text => x);

  dbms_output.put_line(x);
end;
/

WITH TIESşu şekilde genişletilir RANK:

declare
  x VARCHAR2(1000);
begin
 dbms_utility.expand_sql_text(
        input_sql_text => '
          SELECT val
          FROM   rownum_order_test
          ORDER BY val DESC
          FETCH FIRST 5 ROWS WITH TIES',
        output_sql_text => x);

  dbms_output.put_line(x);
end;
/

SELECT "A1"."VAL" "VAL" 
FROM  (SELECT "A2"."VAL" "VAL","A2"."VAL" "rowlimit_$_0",
              RANK() OVER ( ORDER BY "A2"."VAL" DESC ) "rowlimit_$$_rank" 
       FROM "ROWNUM_ORDER_TEST" "A2") "A1" 
WHERE "A1"."rowlimit_$$_rank"<=5 ORDER BY "A1"."rowlimit_$_0" DESC

ve ofset:

declare
  x VARCHAR2(1000);
begin
 dbms_utility.expand_sql_text(
        input_sql_text => '
          SELECT val
FROM   rownum_order_test
ORDER BY val
OFFSET 4 ROWS FETCH NEXT 4 ROWS ONLY',
        output_sql_text => x);

  dbms_output.put_line(x);
end;
/


SELECT "A1"."VAL" "VAL" 
FROM  (SELECT "A2"."VAL" "VAL","A2"."VAL" "rowlimit_$_0",
             ROW_NUMBER() OVER ( ORDER BY "A2"."VAL") "rowlimit_$$_rownumber" 
       FROM "ROWNUM_ORDER_TEST" "A2") "A1" 
       WHERE "A1"."rowlimit_$$_rownumber"<=CASE  WHEN (4>=0) THEN FLOOR(TO_NUMBER(4)) 
             ELSE 0 END +4 AND "A1"."rowlimit_$$_rownumber">4 
ORDER BY "A1"."rowlimit_$_0"

Oracle 12C'de değilseniz, aşağıdaki gibi TOP N sorgusunu kullanabilirsiniz.

SELECT *
 FROM
   ( SELECT rownum rnum
          , a.*
       FROM sometable a 
   ORDER BY name
   )
WHERE rnum BETWEEN 10 AND 20;

Hatta bu maddeyi aşağıdaki maddeden de taşıyabilirsiniz.

WITH b AS
( SELECT rownum rnum
      , a.* 
   FROM sometable a ORDER BY name
) 
SELECT * FROM b 
WHERE rnum BETWEEN 10 AND 20;

Burada aslında satır içi bir görünüm oluşturuyoruz ve rownum'u rnum olarak yeniden adlandırıyoruz. Ana sorgudaki rnum'u filtre ölçütü olarak kullanabilirsiniz.

Ben 12c karşı doğrulanmış Oracle 1z0-047 sınava hazırlanmaya başladım Bunun için hazırlanırken ben 'FETCH FIRST' olarak bilinen bir 12c geliştirme rastladım Size kolaylık göre satır / sınır satır getirmenizi sağlar. Bununla birlikte çeşitli seçenekler mevcuttur

- FETCH FIRST n ROWS ONLY
 - OFFSET n ROWS FETCH NEXT N1 ROWS ONLY // leave the n rows and display next N1 rows
 - n % rows via FETCH FIRST N PERCENT ROWS ONLY

Misal:

Select * from XYZ a
order by a.pqr
FETCH FIRST 10 ROWS ONLY

select * FROM (SELECT 
   ROW_NUMBER() OVER (ORDER BY sal desc),* AS ROWID, 
 FROM EMP ) EMP  where ROWID=5

değerler daha büyük

select * FROM (SELECT 
       ROW_NUMBER() OVER (ORDER BY sal desc),* AS ROWID, 
     FROM EMP ) EMP  where ROWID>5

değerler daha az

select * FROM (SELECT 
       ROW_NUMBER() OVER (ORDER BY sal desc),* AS ROWID, 
     FROM EMP ) EMP  where ROWID=5

Bir sorgu tarafından döndürülen her satır için, ROWNUM sözde sütunu, Oracle'ın satırı tablodan veya birleştirilmiş satırlar kümesinden seçme sırasını gösteren bir sayı döndürür. Seçilen ilk satırın ROWNUM değeri 1, ikincisi 2, vb.

  SELECT * FROM sometable1 so
    WHERE so.id IN (
    SELECT so2.id from sometable2 so2
    WHERE ROWNUM <=5
    )
    AND ORDER BY so.somefield AND ROWNUM <= 100 

Bunu oraclesunucuda uyguladım11.2.0.1.0

SQL-Developer durumunda, yalnızca ilk 50 satırı otomatik olarak getirir. Ve eğer aşağı kaydırırsak, 50 satır daha getirir!

Bu nedenle, sql-geliştirici aracı durumunda tanımlamamız gerekmiyor!

Kehanette

SELECT val FROM   rownum_order_test ORDER BY val DESC FETCH FIRST 5 ROWS ONLY;

VAL

    10
    10
     9
     9
     8

5 satır seçildi.

SQL>

(denenmemiş) böyle bir şey işi yapabilir

WITH
base AS
(
    select *                   -- get the table
    from sometable
    order by name              -- in the desired order
),
twenty AS
(
    select *                   -- get the first 30 rows
    from base
    where rownum < 30
    order by name              -- in the desired order
)
select *                       -- then get rows 21 .. 30
from twenty
where rownum > 20
order by name                  -- in the desired order

Ayrıca, sipariş vermek için kullanabileceğiniz analitik fonksiyon sırası da vardır.

Düzeltmelerle yukarıdaki ile aynı. Çalışır ama kesinlikle hoş değil.

   WITH
    base AS
    (
        select *                   -- get the table
        from sometable
        order by name              -- in the desired order
    ),
    twenty AS
    (
        select *                   -- get the first 30 rows
        from base
        where rownum <= 30
        order by name              -- in the desired order
    )
    select *                       -- then get rows 21 .. 30
    from twenty
    where rownum < 20
    order by name                  -- in the desired order

Dürüst olmak gerekirse, yukarıdaki cevapları kullanmak daha iyidir.