Oracleවිමසුමක් එහි MySQL limitවගන්තියක් අඩංගු වන පරිදි හැසිරීමට ක්‍රමයක් තිබේද?

තුළ MySQL, මට මෙය කළ හැකිය:

select * 
from sometable
order by name
limit 20,10

21 සිට 30 දක්වා පේළි ලබා ගැනීමට (පළමු 20 මඟ හරින්න, ඊළඟ 10 දෙන්න). පේළි තෝරාගෙන ඇත්තේ order by, පසුව එය 20 වන නාමයෙන් අකාරාදී පිළිවෙලින් ආරම්භ වේ.

තුළ Oracle, මිනිසුන් සඳහන් කරන එකම දෙය rownumව්‍යාජ තීරුවයි, නමුත් එය කලින් ඇගයීමට ලක් කෙරේ order by, එයින් අදහස් වන්නේ:

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

පේළි දහයක අහඹු කට්ටලයක් නමින් ඇණවුම් කරනු ඇත, එය සාමාන්‍යයෙන් මට අවශ්‍ය නොවේ. ඕෆ්සෙට් එකක් නියම කිරීමට ද එය ඉඩ නොදේ.

ඔරකල් 12c R1 (12.1) සිට ආරම්භ වන අතර, එහි වන යම් වගන්තියක් සීමා පේළිය . එය හුරුපුරුදු LIMITසින්ටැක්ස් භාවිතා නොකරයි , නමුත් එයට තවත් විකල්ප සමඟ කාර්යය වඩා හොඳින් කළ හැකිය. ඔබට සම්පූර්ණ වාක්‍ය ඛණ්ඩය මෙතැනින් සොයාගත හැකිය . ( මෙම පිළිතුරේ ඔරකල්හි අභ්‍යන්තරව ක්‍රියා කරන ආකාරය පිළිබඳ වැඩිදුර කියවන්න ).

මුල් ප්‍රශ්නයට පිළිතුරු සැපයීම සඳහා මෙන්න විමසුම:

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

(පෙර ඔරකල් අනුවාද සඳහා, කරුණාකර මෙම ප්‍රශ්නයේ වෙනත් පිළිතුරු වෙත යොමු වන්න)

උදාහරණ:

සම්බන්ධක කුණුවීම වැළැක්වීමේ අපේක්ෂාවෙන් සම්බන්ධිත පිටුවෙන් පහත උදාහරණ උපුටා දැක්වීය .

පිහිටුවීම

CREATE TABLE rownum_order_test (
  val  NUMBER
);

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

COMMIT;

මේසයේ ඇත්තේ කුමක්ද?

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.

පළමු 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.

පළමු Nපේළි ලබා ගන්න , N^{තුන්වන} පේළියේ බැඳීම් තිබේ නම් , සියලු බැඳ ඇති පේළි ලබා ගන්න

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.

xපේළි වලින් ඉහළම %

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

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

4 rows selected.

පේජින් කිරීම සඳහා ඉතා ප්‍රයෝජනවත් ඕෆ්සෙට් එකක් භාවිතා කිරීම

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.

ඔබට ඕෆ්සෙට් ප්‍රතිශත සමඟ ඒකාබද්ධ කළ හැකිය

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.

මේ සඳහා ඔබට උපවගන්තියක් භාවිතා කළ හැකිය

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

වැඩි විස්තර සඳහා OOW / AskTom හි ROWNUM සහ ප්‍රති results ල සීමා කිරීම යන මාතෘකාව දෙස බලන්න .

යාවත්කාලීන කිරීම : පහළ සහ ඉහළ සීමාවන් සමඟ ප්‍රති result ලය සීමා කිරීම සඳහා දේවල් තව ටිකක් පුපුරා යයි

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;

(නිශ්චිත AskTom- ලිපියෙන් පිටපත් කරන ලදි)

යාවත්කාලීන 2 : ඔරකල් 12 සී (12.1) සිට පේළි සීමා කිරීමට හෝ ඕෆ්සෙට් වලින් ආරම්භ කිරීමට සින්ටැක්ස් තිබේ.

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

තවත් උදාහරණ සඳහා මෙම පිළිතුර බලන්න . ඉඟිය සඳහා කෘමියාට ස්තූතියි.

පහත දැක්වෙන ප්‍රවේශයන් සඳහා මම කාර්ය සාධන පරීක්ෂණ කිහිපයක් කළෙමි:

Asktom

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

විශ්ලේෂණාත්මක

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

කෙටි විකල්ප

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

ප්රතිපල

වගුවට වාර්තා මිලියන 10 ක් තිබුණි, වර්ග කිරීම අනපේක්ෂිත දිවා කාල පේළියක විය:

• පැහැදිලි කිරීමේ සැලැස්ම තේරීම් තුනටම සමාන අගයක් පෙන්වයි (323168)
• නමුත් ජයග්‍රාහකයා වන්නේ AskTom (විශ්ලේෂණාත්මක පහත දැක්වෙන පිටුපසින්)

පළමු පේළි 10 තෝරා ගැනීම සඳහා ගත වූයේ:

• AskTom: තත්පර 28-30
• විශ්ලේෂණ: තත්පර 33-37
• කෙටි විකල්පය: තත්පර 110-140

100,000 සහ 100,010 අතර පේළි තෝරා ගැනීම:

• AskTom: තත්පර 60 යි
• විශ්ලේෂණ: තත්පර 100 යි

9,000,000 ත් 9,000,010 ත් අතර පේළි තෝරා ගැනීම:

• AskTom: තත්පර 130 යි
• විශ්ලේෂණ: තත්පර 150 යි

එක් කැදැලි විමසුමක් සහිත විශ්ලේෂණ විසඳුමක්:

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

Rank()වෙනුවට ආදේශ කළ හැකි Row_Number()නමුත් නම සඳහා අනුපිටපත් අගයන් තිබේ නම් ඔබ බලාපොරොත්තු වනවාට වඩා වැඩි වාර්තා ලබා දිය හැකිය .

ඔරකල් 12 සී මත ( SQL යොමුවෙහි පේළි සීමා කිරීමේ වගන්තිය බලන්න ):

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

ඇණවුම් කිරීම සමඟ පේජින් විමසීම් ඔරකල්හි ඇත්තෙන්ම උපක්‍රමශීලී ය.

ඔරකල් විසින් ROWNUM ව්‍යාජ තීරුවක් සපයන අතර එමඟින් දත්ත සමුදාය වගුවකින් පේළිය තෝරාගත් අනුපිළිවෙල හෝ සම්බන්ධිත දර්ශන සමූහයක් දක්වයි.

ROWNUM යනු බොහෝ මිනිසුන් කරදරයට පත් කරන ව්‍යාජ තීරුවකි. ROWNUM අගයක් පේළියකට ස්ථිරවම පවරා නොමැත (මෙය පොදු වරදවා වටහා ගැනීමකි). ROWNUM අගයක් සැබවින්ම පවරා ඇති විට එය ව්‍යාකූල විය හැකිය. පේළියකට ROWNUM අගයක් පවරනු ලබන්නේ එය විමසුමේ පෙරහන් අනාවැකි පසු කළ නමුත් විමසුම් එකතු කිරීමට හෝ වර්ග කිරීමට පෙරය .

එපමණක්ද නොව, ROWNUM අගය වැඩි කරනු ලබන්නේ එය පවරා දීමෙන් පසුව පමණි.

අනුගාමික විමසුම පේළි කිසිවක් නොදෙන්නේ මේ නිසා ය:

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

විමසුම් ප්‍රති result ලයේ පළමු පේළිය ROWNUM> 1 අනාවැකිය පසු නොකරයි, එබැවින් ROWNUM 2 ට වැඩි නොවේ. මේ හේතුව නිසා කිසිදු ROWNUM අගයක් 1 ට වඩා වැඩි නොවේ, එම නිසා විමසුම පේළි කිසිවක් ලබා නොදේ.

නිවැරදිව අර්ථ දක්වා ඇති විමසුම මේ ආකාරයට විය යුතුය:

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

වර්ටබෙලෝ බ්ලොග් අඩවියේ මගේ ලිපිවල පේජින් විමසීම් ගැන වැඩි විස්තර සොයන්න :

• ඔරකල් ROWNUM පැහැදිලි කරන ලදි
• ඉහළ-එන් සහ පේජින් විමසුම්

SQL ප්‍රමිතිය

මෙම ලිපියෙන් මා පැහැදිලි කළ පරිදි , SQL: 2008 ප්‍රමිතිය SQL ප්‍රති result ල කට්ටලය සීමා කිරීම සඳහා පහත සඳහන් වාක්‍ය ඛණ්ඩය සපයයි:

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

ඔරකල් 11g සහ පැරණි අනුවාද

12c අනුවාදයට පෙර, Top-N වාර්තා ලබා ගැනීම සඳහා, ඔබට ව්‍යුත්පන්න වගුවක් සහ ROWNUM ව්‍යාජ තීරුව භාවිතා කිරීමට සිදු විය:

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

අඩු SELECT ප්‍රකාශ. එසේම, අඩු කාර්ය සාධනය පරිභෝජනය කරයි. බැර: anibal@upf.br

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

පිළිගත් පිළිතුරේ දිගුවක් ලෙස ඔරකල් අභ්‍යන්තරව ROW_NUMBER/RANKකාර්යයන් භාවිතා කරයි. OFFSET FETCHසින්ටැක්ස් යනු සින්ටැක්ස් සීනි ය.

DBMS_UTILITY.EXPAND_SQL_TEXTක්රියා පටිපාටිය භාවිතා කිරීමෙන් එය නිරීක්ෂණය කළ හැකිය :

නියැදිය සකස් කිරීම:

CREATE TABLE rownum_order_test (
  val  NUMBER
);

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

විමසුම:

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

නිත්‍යයි:

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 <> ෆෙඩල් නිරූපණය

පුළුල් කළ SQL පෙළ ලබා ගැනීම:

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පුළුල් කර ඇත්තේ 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

සහ ඕෆ්සෙට්:

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"

ඔබ ඔරකල් 12 සී හි නොමැති නම්, ඔබට පහත පරිදි TOP N විමසුම භාවිතා කළ හැකිය.

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

ඔබට මෙය පහත වගන්තියෙන් වගන්තියෙන් ගෙන යා හැකිය

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

මෙන්න ඇත්ත වශයෙන්ම අපි පේළිගත දර්ශනයක් නිර්මාණය කරමින් රව්නම් rnum ලෙස නම් කරමු. පෙරහන් නිර්ණායක ලෙස ඔබට ප්‍රධාන විමසුමේ rnum භාවිතා කළ හැකිය.

මම 12c ට එරෙහිව වලංගු කරන ලද ඔරකල් 1z0-047 විභාගයට සූදානම් වීම ආරම්භ කළෙමි. ඒ සඳහා සූදානම් වන විට මට 12c වැඩි දියුණු කිරීමක් හමු විය. එය 'FETCH FIRST' නමින් හැඳින්වේ. ඒ සමඟ විකල්ප කිහිපයක් තිබේ

- 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

උදාහරණයක්:

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

වඩා විශාල අගයන් සොයා ගනී

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

අඩුවෙන් පසුව අගයන් සොයා ගනී

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

විමසුමකින් ආපසු එන සෑම පේළියක් සඳහාම, ROWNUM ව්‍යාජ තීරුව ඔරකල් විසින් වගුවකින් හෝ පේළි සමූහයකින් පේළිය තෝරා ගන්නා අනුපිළිවෙල දැක්වෙන අංකයක් ලබා දෙයි. තෝරාගත් පළමු පේළියේ ROWNUM 1 ක් ද, දෙවන පේළියට 2 ක් ද ඇත.

  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 

මම මෙය oracleසේවාදායකයේ ක්‍රියාත්මක කර ඇත්තෙමි11.2.0.1.0

SQL- සංවර්ධකයා සම්බන්ධයෙන්, එය ස්වයංක්‍රීයව ලබා ගන්නේ පළමු පේළි 50 ක් පමණි. අපි පහළට අනුචලනය කළහොත්, එය තවත් පේළි 50 ක් ලබා ගනී.

එබැවින් වර්ග-සංවර්ධක මෙවලමක් නම් අපට නිර්වචනය කිරීමට අවශ්‍ය නැත!

ඔරකල් වල

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

VAL

    10
    10
     9
     9
     8

පේළි 5 ක් තෝරාගෙන ඇත.

SQL>

(පරීක්ෂා නොකළ) මේ වගේ දෙයක් එම කාර්යය කළ හැකිය

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

ඔබට ඇණවුම් කිරීමට භාවිතා කළ හැකි විශ්ලේෂණ ශ්‍රිත ශ්‍රේණිය ද ඇත.

නිවැරදි කිරීම් සමඟ ඉහත සඳහන් කළ ආකාරයටම. වැඩ කරන නමුත් අනිවාර්යයෙන්ම ලස්සන නැත.

   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

අවංකවම, ඉහත පිළිතුරු භාවිතා කිරීම වඩා හොඳය.