पहले 10 अप्रयुक्त मैन्युअल_अनुक्रम संख्याएँ प्राप्त करना

पहले मैं इस परिष्कृत सबक्वेरी को बदलूंगा:

Select Rownum seq_number From Dual Connect By Rownum <= 
         (Select LPAD(9,(UTC.DATA_PRECISION - UTC.DATA_SCALE),9) 
          From User_Tab_Columns UTC 
          where UTC.Table_Name = 'Table_Name' And UTC.Column_Name = 'seq_number')

इसके साथ:

Select Rownum As seq_number From Dual 
Connect By Rownum <= (Select max( seq_number ) + 10 From TEMP_TABLE_NAME ) 

या एक साधारण स्थिरांक के साथ भी:

Select Rownum As seq_number From Dual Connect By Rownum <= 1000000

आपकी सबक्वायरी स्पष्ट रूप से एक बहुत ही बुनियादी मामले के लिए काम नहीं करती है:

create table TEMP_TABLE_NAME(
  seq_number NUMBER
);

SELECT LPAD (9,(UTC.DATA_PRECISION - UTC.DATA_SCALE),9) as x , 
       UTC.DATA_PRECISION, UTC.DATA_SCALE, UTC.COLUMN_NAME
FROM User_Tab_Columns UTC
WHERE     UTC.Table_Name = 'TEMP_TABLE_NAME'
  AND UTC.Column_Name = 'SEQ_NUMBER'
;

X        DATA_PRECISION DATA_SCALE COLUMN_NAME
-------- -------------- ---------- -----------
  (null)         (null)     (null) SEQ_NUMBER

और दूसरा मामला:

create table TEMP_TABLE_NAME(
  seq_number NUMBER(15,0)
);

इस मामले में सबक्वेरी 999999999999999 पंक्तियों को उत्पन्न करने का प्रयास करती है, जो जल्दी से स्मृति त्रुटि की ओर ले जाती है

SELECT count(*) FROM (
 SELECT ROWNUM seq_number
              FROM DUAL
        CONNECT BY ROWNUM <=
                      (SELECT LPAD (9,(UTC.DATA_PRECISION - UTC.DATA_SCALE),9)
                         FROM User_Tab_Columns UTC
                        WHERE     UTC.Table_Name = 'TEMP_TABLE_NAME'
                              AND UTC.Column_Name = 'SEQ_NUMBER')
);

ORA-30009: Not enough memory for CONNECT BY operation
30009. 0000 -  "Not enough memory for %s operation"
*Cause:    The memory size was not sufficient to process all the levels of the
           hierarchy specified by the query.
*Action:   In WORKAREA_SIZE_POLICY=AUTO mode, set PGA_AGGREGATE_TARGET to
           a reasonably larger value.
           Or, in WORKAREA_SIZE_POLICY=MANUAL mode, set SORT_AREA_SIZE to a
           reasonably larger value.

दूसरी बात, आपकी क्वेरी नियतात्मक नहीं है !!!
यह दृढ़ता से एक भौतिक तालिका संरचना पर निर्भर करता है और ORDER BY का उपयोग करके सही क्रम नहीं लगाता है खंड।
याद रखें ->विकिपीडिया - ऑर्डर बाय

इस परीक्षण मामले पर विचार करें:

create table TEMP_TABLE_NAME 
as SELECT * FROM (
    select rownum as seq_number , t.*
    from ALL_OBJECTS t
    cross join ( select * from dual connect by level <= 10)
    where rownum <= 100000
)
ORDER BY DBMS_RANDOM.Value;
create unique index TEMP_TABLE_NAME_IDX on TEMP_TABLE_NAME(seq_Number);

select count(*) from TEMP_TABLE_NAME;
  COUNT(*)
----------
    100000

DELETE FROM TEMP_TABLE_NAME
WHERE seq_number between 10000 and 10002
  OR seq_number between 20000 and 20002
  OR seq_number between 30000 and 30002
  OR seq_number between 40000 and 40002
  OR seq_number between 50000 and 50002
  OR seq_number between 60000 and 60002
  ;

यदि अनुक्रमणिका मौजूद है, तो परिणाम ठीक है:

SELECT T1.*
  FROM (    SELECT ROWNUM seq_number
              FROM DUAL
        CONNECT BY ROWNUM <= 1000000
) T1,
       TEMP_TABLE_NAME T2
 WHERE     T1.seq_number = T2.seq_number(+)
       AND T2.ROWID IS NULL
       AND ROWNUM <= 10
;

SEQ_NUMBER
----------
     10000
     10001
     10002
     20000
     20001
     20002
     30000
     30001
     30002
     40000

लेकिन क्या होता है जब किसी दिन कोई इंडेक्स को हटा देता है, या ऑप्टिमाइज़र कुछ कारणों से उस इंडेक्स का उपयोग नहीं करने का फैसला करता है?
परिभाषा के अनुसार:बिना ORDER BY, रिलेशनल डेटाबेस सिस्टम किसी भी में पंक्तियों को वापस कर सकता है आदेश। मैं एक संकेत का उपयोग करके इन मामलों का अनुकरण करता हूं:

SELECT /*+ NO_INDEX(T2) */ T1.*
  FROM (    SELECT ROWNUM seq_number
              FROM DUAL
        CONNECT BY ROWNUM <= 1000000
) T1,
       TEMP_TABLE_NAME T2
 WHERE     T1.seq_number = T2.seq_number(+)
       AND T2.ROWID IS NULL
       AND ROWNUM <= 10
;

SEQ_NUMBER
----------
    213856
    910281
    668862
    412743
    295487
    214762
    788486
    346216
    777734
    806457

नीचे दी गई क्वेरी ORDER BY . का उपयोग करके एक उचित आदेश लागू करती है खंड और प्रजनन परिणाम देता है, भले ही उचित सूचकांक मौजूद हो या न हो। वाक्य रचना।

SELECT  * FROM (
    SELECT /*+ NO_INDEX(T2) */ T1.*
      FROM (    SELECT ROWNUM seq_number
                  FROM DUAL
            CONNECT BY ROWNUM <= 1000000
    ) T1 
    LEFT JOIN TEMP_TABLE_NAME T2
    ON T1.seq_number = T2.seq_number
    WHERE T2.ROWID IS NULL
    ORDER BY T1.seq_number
)
WHERE ROWNUM <= 10

प्रदर्शन
प्रदर्शन जांचने का सबसे आसान तरीका एक परीक्षण करना है - क्वेरी को 10 से 100 बार चलाएं और समय मापें:

SET TIMING ON;
DECLARE
   x NUMBER;
BEGIN
   FOR i IN 1..10 LOOP
      SELECT sum( seq_number ) INTO x
      FROM (
           SELECT  * FROM (
            SELECT T1.*
              FROM (    SELECT ROWNUM seq_number
                          FROM DUAL
                    CONNECT BY ROWNUM <= 1000000
            ) T1 
            LEFT JOIN TEMP_TABLE_NAME T2
            ON T1.seq_number = T2.seq_number
            WHERE T2.ROWID IS NULL
            ORDER BY T1.seq_number
            )
            WHERE ROWNUM <= 10
        );
    END LOOP;
END;
/

PL/SQL procedure successfully completed.

Elapsed: 00:00:11.750

10 बार - 11.75 सेकंड, इसलिए एक प्रश्न में 1,2 सेकंड लगते हैं।

और एक अगला संस्करण जहां CONNECT BY . में एक सीमा है एक सबक्वेरी का उपयोग करता है:

SET TIMING ON;
DECLARE
   x NUMBER;
BEGIN
   FOR i IN 1..10 LOOP
      SELECT sum( seq_number ) INTO x
      FROM (
           SELECT  * FROM (
            SELECT T1.*
              FROM (    SELECT ROWNUM seq_number
                          FROM DUAL
                    CONNECT BY ROWNUM <= (Select max( seq_number ) + 10 From TEMP_TABLE_NAME ) 
            ) T1 
            LEFT JOIN TEMP_TABLE_NAME T2
            ON T1.seq_number = T2.seq_number
            WHERE T2.ROWID IS NULL
            ORDER BY T1.seq_number
            )
            WHERE ROWNUM <= 10
        );
    END LOOP;
END;
/
PL/SQL procedure successfully completed.

Elapsed: 00:00:00.986

बहुत बेहतर - केवल 100 मिलीसेकंड।
इससे यह निष्कर्ष निकलता है, कि इससे कनेक्ट करें हिस्सा सबसे महंगा है।

एक और प्रयास जो कनेक्ट बाय के बजाय 1 mln (एक प्रकार का भौतिक दृश्य) तक की संख्याओं के पूर्व-जनरेटेड अनुक्रम वाली तालिका का उपयोग करता है सबक्वेरी जो हर बार मेमोरी में फ्लाई पर नंबर जेनरेट करती है:

create table seq(
   seq_number int primary key
)
ORGANIZATION INDEX ;

INSERT INTO seq 
SELECT level FROM dual
CONNECT BY LEVEL <= 1000000;

SET TIMING ON;
DECLARE
   x NUMBER;
BEGIN
   FOR i IN 1..10 LOOP
      SELECT sum( seq_number ) INTO x
      FROM (
           SELECT  * FROM (
            SELECT T1.*
            FROM seq T1 
            LEFT JOIN TEMP_TABLE_NAME T2
            ON T1.seq_number = T2.seq_number
            WHERE T2.ROWID IS NULL
            ORDER BY T1.seq_number
            )
            WHERE ROWNUM <= 10
        );
    END LOOP;
END;
/

PL/SQL procedure successfully completed.

Elapsed: 00:00:00.398

यह सबसे तेज़ है - केवल 40 ms

पहला वाला 1200 ms, अंतिम वाला 40ms - 30 गुना तेज़ (3000%)।