In quali condizioni ROWNUM = 1 aumenta significativamente le prestazioni in una query sile "esistente"

Question

Ho letto alcune delle discussioni in this question e ho pensato a me stesso che nel mio codice PL/SQL ho "esistenti" query di stile in tutto il luogo che non usa l'ottimizzazione ROWNUM = 1.

Le domande che ho sono:

1. Fa l'introduzione di ROWNUM = 1 aumentare in modo significativo le prestazioni?
2. In caso affermativo, in quali condizioni sarebbero le prestazioni siano migliorate in particolare (ad esempio, un sacco di join, vincoli sulle colonne non indicizzati, tabelle di grandi dimensioni, grandi insiemi di risultati)

Sto cercando di determinare sia il valore di riscrivere tutto delle mie query esistenti per aggiungere un'ottimizzazione ROWNUM = 1.

Le query a cui sto pensando sono quelle che possono avere più join e possono eseguire query su tabelle di grandi dimensioni. Hanno la forma generale di:

SELECT 1 
INTO ln_count 
FROM table_1, table_2...., table_n 
WHERE <various joins and conditions>; 

IF ln_count > 0 THEN 
    <do stuff> 
END IF; 

sto considerando cambiarle a:

SELECT 1 
INTO ln_count 
FROM table_1, table_2...., table_n 
WHERE <various joins and conditions> 
AND ROWNUM = 1; 

IF <local variable> > 0 THEN 
    <do stuff> 
END IF; 

Answer 1

Migliora significativamente le prestazioni (media delle decine di percento) su query che non possono essere risolte mediante una semplice ricerca per indice singolo, ad es. tavolo unisce. Tuttavia è potenzialmente in grado di nascondere l'errore di dati/applicazione.

Consente di avere una tabella:

create table t (id number(10,0), padding varchar2(1000)); 

--intentionally non utilizzare PK per fare l'esempio più semplice possibile. L'imbottitura è utilizzato per simulare il carico reale i dati in ogni record

con molti record:

insert into t (id, padding) 
select rownum, rpad(' ', 1000) from dual connect by level < 10000 

Ora, se si chiede qualcosa di simile

select 1 into ll_exists 
from t where id = 5; 

il DB deve passare attraverso l'intera tabella se ha trovato l'unico record corrispondente nel primo blocco di dati (che tra l'altro non possiamo sapere perché potrebbe essere inserito in molti modi diversi) o nell'ultimo. Questo perché non sa che esiste un solo record corrispondente. D'altra parte se si usa ... e rownum = 1 allora si può smettere di attraversare i dati dopo che il record è stato trovato perché gli è stato detto che non c'è (o non è necessario) un altro record corrispondente.

Lo svantaggio è che con il vincolo di rownum è possibile ottenere risultati non deterministici se i dati contengono più di un record possibile. Se la query è stata

select id into ll_id 
from t where mod (id, 2) = 1 
and rownum = 1; 

poi possono ricevere dalla risposta DB 1 e 3, nonché 123 ... fine non è garantito e questo è la conseguenza. (senza la clausola rownum vorrei ottenere un'eccezione TOO_MANY_ROWS. Dipende dalla situazione quale è peggiore)

Se si desidera veramente eseguire query sulla verifica dell'esistenza, WRITE IT THAT WAY.

begin 

select 'It does' 
    into ls_exists 
from dual where 
exists (your_original_query_without_rownum); 

do_something_when_it_does_exist 
exception 
    when no_data_found then 
    do_something_when_it_doesn't_exist 
end; 

Answer 2

ho intenzione di indovinare che questo non sta per essere degno il vostro tempo. I moderni ottimizzatori sono molto bravi in ​​quello che fanno quindi troverei un po 'sorprendente che una query che è CONSENTITA di restituire solo una riga vedrà un significativo incremento delle prestazioni dall'aggiunta di ROWNUM = 1.

Si suppone che il guadagno di prestazioni rimuova la necessità di verificare questo vincolo?

trovo quando smetto di fidarsi l'ottimizzatore spesso scavare me stesso una tomba più profondo;)

Inoltre: In caso di dubbio provarlo. Trova un join di grandi dimensioni, eseguilo più volte senza rownum = 1, più volte con rownum = 1 e verifica se stai notando un notevole miglioramento percentuale. Per garantire che non ci siano problemi di memorizzazione nella cache, suggerirei di farlo su un database che è possibile riavviare.

Answer 3

Una regola empirica nell'ottimizzazione consiste nel non farlo a meno che non si disponga di un hotspot da correggere. Tuttavia, se si è interessati ai vantaggi in termini di prestazioni, è possibile eseguire alcuni test utilizzando entrambi per verificare se è possibile misurare qualsiasi prestazione migliorata.

wikipedia quotes Donald Knuth come dicendo:

"dobbiamo dimenticare piccole efficienze, dicono circa il 97% del tempo: l'ottimizzazione prematura è la radice di tutti i mali".

Answer 4

Se si richiede COUNT (1), Oracle deve trovare tutte le righe corrispondenti per soddisfare la risposta esatta.

SELECT COUNT(1) FROM .... 

Se chiedete 1 dalla prima fila, Oracle può fermare una volta che ha trovato una riga corrispondente.

SELECT 1 FROM ... WHERE ROWNUM = 1 

È buona norma chiedere solo i dati effettivamente necessari. Perché ottenere Oracle per dirti che ci sono 1.203.499 risultati corrispondenti quando ti interessa solo il primo?Le persone hanno detto che l'ottimizzatore può migliorare le cose. Tuttavia, deve ancora rispondere alla domanda che hai chiesto. Se fai una domanda più facile, può trovare la risposta più velocemente.

I tempi è probabile avere un impatto significativo sulle prestazioni: - * Il conteggio effettivo di record a trovare è alta, * Oracle passa da un hash JOIN piano per un annidati LOOP, e il piano di ciclo nidificato è meglio per trovare la prima riga

Answer 5

L'introduzione di ROWNUM = 1 aumenta significativamente le prestazioni?

Può fare una differenza molto significativa. Se ti interessa solo la prima riga che il database trova quando esegue la query, allora è meglio dire a Oracle che, aggiungendo "ROWNUM = 1". Se non lo fai, Oracle assumerà che intendi recuperare tutte le righe dalla query alla fine e ottimizzerà la query di conseguenza.

Nel caso di COUNT(), se si desidera solo sapere se è presente almeno un record, il Query Optimiser non lo saprà e conterrà ogni riga, una perdita di tempo. Se aggiungi ROWNUM = 1, hai dato all'ottimizzatore la possibilità di fermarsi non appena trova una riga.

caso affermativo, in quali condizioni sarebbero prestazioni siano particolarmente migliorate (es sacco di join, vincoli sulle colonne non indicizzati, grandi tavoli, grandi insiemi risultato)

I dati più query deve per rispondere alla tua domanda, più il predicato ROWNUM = 1 è in grado di migliorare le prestazioni. In un join a più tabelle, ad esempio, l'aggiunta di ROWNUM = 1 potrebbe modificare il piano dall'utilizzo di molti costosi join di hash, per utilizzare invece cicli nidificati, che sono molto più veloci quando esistono le righe.

Answer 6

Mentre mi piace il più alto votato risposta, nel tentativo di evitare eccezioni, faccio qualcosa di simile:

begin 

    select count(*) 
    into ls_exists 
    from dual 
    where exists (select null from ... where ...); 

    if ls_exists = 1 then 
    do_something; 
    else 
    do_something_else; 
    end if; 

end; 

Ciò sempre restituire una singola riga con un 1 o uno 0 . Nessuna eccezione.

Nota anche l'uso di SELECT NULL. Questo fa un paio di cose; quando l'ottimizzatore pensa che sia appropriato, Oracle controllerà solo gli indici. Se inserisci le colonne della tabella nella clausola SELECT e le colonne non fanno parte di un indice, Oracle eseguirà la ricerca dell'indice, quindi recupererà la riga dalla tabella, che potrebbe essere totalmente inutile in base alla query. Dal momento che stai controllando solo l'esistenza di una riga, probabilmente non hai bisogno di dati reali.

SELECT NULL non restituisce alcun dato (un'ottimizzazione) e la clausola EXISTS controlla se viene restituita una riga, non i dati nella riga.