N Update zufällige Zeilen in SQL

Habe ich die Tabelle mit über 1000 Zeilen.Ich habe zum aktualisieren einer Spalte("X") in der Tabelle " Y " für n ramdom Zeilen. Dafür habe ich folgende Abfrage

update xyz set X='Y' when m in (
'SELECT m FROM (SELECT m
FROM xyz
order by dbms_random.value
) RNDM 
where rownum < n+1);

Gibt es eine weitere effiziente Art und Weise zu schreiben, diese Abfrage. Die Tabelle hat keinen index.
Bitte helfen?

Wenn Sie nicht wirklich wichtig ist, welche Zeilen aktualisiert werden, was ist falsch mit, nur die Aktualisierung der top - rownum Zeilen? Wenn es keinen expliziten Auftrag an den Befehl, erhalten Sie eine nicht-guarunteed Bestellung (zugegeben, es ist wahrscheinlich, Datei-einfügen, aber nicht zwingend) in jedem Fall. Die Aktualisierung "eine zufällige Zeile" in der Regel bedeutet "I don' T care, die ein" - es sei denn, Sie benötigen es in der Tabelle verteilt werden, an welcher Stelle könnten Sie wählen nur jeder fünfte oder so etwas (möglicherweise durch die id Spalte).
Könnte sein, dass das update ist Teil eines Prozesses für die Probenahme-Datensätze für eine weitere überprüfung, Test, QA, etc. In dem Fall random versus nicht-ist bestimmt ein wichtiger Unterschied. Das ist, was ich nahm an, der OP sucht, wenn er fragte nach dem Zufallsprinzip.
Oder für die Angabe von random contest belohnt; Sie könnte Recht haben.

InformationsquelleAutor Niraj Choubey | 2011-08-25

9

Würde ich die ROWID:
```
UPDATE xyz SET x='Y' WHERE rowid IN (
    SELECT r FROM (
        SELECT ROWID r FROM xyz ORDER BY dbms_random.value
    ) RNDM WHERE rownum < n+1
)
```
Den eigentlichen Grund würde ich ROWID ist nicht für die Effizienz, obwohl (es wird noch ein full table scan) - Ihre SQL kann nicht aktualisieren Sie die Anzahl der Zeilen, die Sie wollen, wenn Spalte m ist nicht einzigartig.

Mit nur 1000 Zeilen, die Sie nicht wirklich besorgt über die Effektivität (vielleicht mit hundert Millionen Zeilen). Ohne index auf diese Tabelle, in der Sie stecken dabei einen full table scan wählen, zufällige Datensätze.

[EDIT:] "Aber was ist, wenn es 100.000 Zeilen"

Gut, das ist immer noch 3 Größenordnungen weniger als 100 Millionen.

Lief ich die folgenden:
```
create table xyz as select * from all_objects;
```
[erstellt etwa 50.000 Zeilen auf meinem system - nicht indiziert, genau wie deine Tabelle]
```
UPDATE xyz SET owner='Y' WHERE rowid IN (
     SELECT r FROM (
          SELECT ROWID r FROM xyz ORDER BY dbms_random.value
     ) RNDM WHERE rownum < 10000
);
commit;
```
Dieser dauerte etwa 1,5 Sekunden. Vielleicht war es 1 Sekunde, vielleicht bis zu 3 Sekunden (nicht formal die Zeit, die es brauchte es nur genug Zeit zu blinken).

InformationsquelleAutor Gerrat
7

Können Sie die Leistung verbessern, durch Austausch der full table scan mit einer Probe.

Das erste problem, das Sie in ausgeführt wird, dass Sie nicht verwenden können, die PROBE in einem DML-Unterabfrage ORA-30560: SAMPLE clause not allowed. Aber logisch das ist, was benötigt wird:
```
UPDATE xyz SET x='Y' WHERE rowid IN (
    SELECT r FROM (
        SELECT ROWID r FROM xyz sample(0.15) ORDER BY dbms_random.value
    ) RNDM WHERE rownum < 100/*n*/+1
);
```
Können Sie dies umgehen, indem mit Hilfe einer collection zu speichern, die rowids, und aktualisieren Sie dann die Zeilen mit der rowid-Sammlung. Normalerweise bricht eine Abfrage in einzelne Teile und kleben Sie zusammen mit PL/SQL führt zu schrecklichen Leistung. Aber in diesem Fall können Sie immer noch sparen eine Menge Zeit durch eine signifikante Reduzierung der Menge der zu lesenden Daten.
```
declare
    type rowid_nt is table of rowid;
    rowids rowid_nt;
begin
    --Get the rowids
    SELECT r bulk collect into rowids
    FROM (
        SELECT ROWID r
        FROM xyz sample(0.15)
        ORDER BY dbms_random.value
    ) RNDM WHERE rownum < 100/*n*/+1;

    --update the table
    forall i in 1 .. rowids.count
        update xyz set x = 'Y'
        where rowid = rowids(i);
end;
/
```
Habe ich mal einen einfachen test mit 100.000 Zeilen (für eine Tabelle mit nur zwei Spalten) und N = 100.
Die ursprüngliche version dauerte 0.85 Sekunden, @Gerrat die Antwort dauerte 0,7 Sekunden, und der PL/SQL-version nahm 0.015 Sekunden.

Aber das ist nur ein Szenario, ich habe nicht genügend Informationen zu sagen, meine Antwort wird immer besser. Als N erhöht sich die sampling-Vorteil verloren, und die Schrift wird wichtiger sein als das Lesen. Wenn Sie eine sehr kleine Menge von Daten, die PL/SQL-Kontext-switching-overhead in meiner Antwort machen Sie es langsamer als @Gerrat Lösung.

Für performance-Probleme, die Größe der Tabelle in Byte ist in der Regel viel wichtiger als die Größe in Zeilen. 1000 Zeilen, die mit einem terabyte Speicherplatz ist viel größer als 100 Mio Zeilen, die nur mit einem gigabyte.

Hier sind einige Probleme zu berücksichtigen, mit meiner Antwort:
1. Probenahme nicht immer wieder genau die Prozent Sie gefragt haben. Mit 100.000 Zeilen und eine 0,15% - Stichprobe der Größe die Anzahl der Zeilen, die zurückgegeben wurde, 147, und nicht 150. Das ist, warum ich verwendet, um 0,15 statt 0,10. Sie müssen über-Beispiel ein wenig, um sicherzustellen, dass Sie mehr bekommen, als N. Wie viel Sie brauchen, um over-Muster? Ich habe keine Idee, werden Sie wahrscheinlich haben, um es zu testen, und wählen Sie eine sichere Nummer.
2. Die Sie brauchen, um zu wissen, die Ungefähre Anzahl der Zeilen auswählen, die Prozent.
3. Die Prozent muss ein literal, also als die Anzahl der Zeilen und N ändern, müssen Sie dynamisches SQL verwenden, um ändern Sie die Prozent.
- Nette, informative Antwort. Als ich aber erwähnen, das die Probenahme, aber es ist nur unnötige Komplexität/overkill in 99% der Fälle. Es ist gut zu erwähnen aber für diejenigen, die mit einem überwältigenden Bedürfnis für die vorzeitige Optimierung. 🙂
InformationsquelleAutor Jon Heller

Folgende Lösung funktioniert Prima. Es ist robust und scheint ähnlich zu sein sample():

create table t1 as 
    select level id, cast ('item'||level as varchar2(32)) item 
    from dual connect by level<=100000; 

Table T1 created.

update t1 set item='*'||item 
where exists (
    select rnd from (
        select dbms_random.value() rnd
        from t1
    ) t2 where t2.rowid = t1.rowid and rnd < 0.15
);

14,858 rows updated.

Elapsed: 00:00:00.717

Bedenken Sie, dass alias rnd enthalten sein müssen in der select-Klausel. Sonst ändert sich die omptimizer der filter predicat aus RND<0.1 zu DBMS_RANDOM.VALUE()<0.1. In diesem Fall dbms_random.value wird nur einmal ausgeführt.

Wie bereits in der Antwort @JonHeller, die beste Lösung bleibt die pl/sql-code-block, da es ermöglicht, um full table scan. Hier ist mein Vorschlag:

create or replace type rowidListType is table of varchar(18);  
/
create or replace procedure updateRandomly (prefix varchar2 := '*') is
    rowidList rowidListType;  
begin  
    select rowidtochar (rowid) bulk collect into rowidList
    from t1 sample(15)
    ;
    update t1 set item=prefix||item 
    where exists (
        select 1 from table (rowidList) t2
        where chartorowid(t2.column_value) = t1.rowid
    );
    dbms_output.put_line ('updated '||sql%rowcount||' rows.'); 
end;
/
begin  updateRandomly; end;
/ 

Elapsed: 00:00:00.293
updated 14892 rows.

InformationsquelleAutor 0xdb

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.