Aggregieren zu 'einfachen' Abfrage

Question

Ich habe eine Abfrage, die Aggregatfunktionen verwendet, um die maximum absolute der Werte einer anderen Spalte in der Tabelle zuzuweisen. Das Problem ist, dass es viel Zeit in Anspruch nimmt (ca. 10-15 Sekunden), um die Abschlusszeit abzufragen. Dies ist, was die Abfrage wie folgt aussieht:

UPDATE calculated_table c 
    SET tp = (SELECT MAX(ABS(s.tp)) 
       FROM ts s INNER JOIN tc t ON s.id = t.id 
       GROUP BY s.id); 

Wo id nicht eindeutig ist, damit die Gruppierung. tp ist ein numerisches ganzzahliges Feld. Hier ist, was die Tabellen wie folgt aussehen:

TABLE ts 
     PID(primary)  |   id (FKEY)    |      tp (integer)     
--------------------+-----------------------------+------------------------------------------------------ 
1      | 2        | -100 
2      | 2        | -500 
3      | 2        | -1000 

TABLE tc 
     PID(primary)  |   id (FKEY)        
--------------------+-----------------------------+------------------------- 
1      | 2        

ich die Ausgabe aussehen soll:

TABLE c 
     PID(primary)  |   tp (integer)     
--------------------+-----------------------------+-------- 
1      | 1000         

Ich habe versucht, es so funktioniert:

UPDATE calculated_table c 
    SET tp = (SELECT s.tp 
       FROM ts s INNER JOIN tc t ON s.id = t.id 
       ORDER BY s.tp DESC 
       LIMIT 1); 

Obwohl es die verbesserte Leistung, aber die Ergebnisse sind falsch .. jede Hilfe wäre willkommen?

Answer 1

Ich habe es geschafft, die Abfrage zu verändern, turnsout aggregate functions nisten keine gute Option ist. wenn es jemand hilft aber, hier ist das, was ich tun endete:

UPDATE calculated_table c 
    SET tp = (SELECT ABS(s.trade_position) 
       FROM ts s INNER JOIN tc t ON s.id = t.id 
       WHERE c.id = s.id 
       ORDER BY ABS(s.tp) DESC 
       LIMIT 1); 

Answer 2

Versuchen:

UPDATE calculated_table c 
    SET tp = (SELECT greatest(MAX(s.tp) , - MIN(s.tp)) 
       FROM ts s INNER JOIN tc t ON s.id = t.id 
       WHERE c.id = s.id 
      ); 

versuchen auch auf einen mehrspaltigen Index zu erstellen ts(id, tp)

Answer 3

ich die folgenden SQL hoffen, Sie wird hilfreich sein, testete ich in Netezza, aber nicht postgresql. Außerdem habe ich update nicht darüber gelegt.

SELECT ABS (COM.TP) VON TC C LEFT OUTER JOIN
(SELECT ID, TP TS FROM A WHERE NICHT EXISTIERT (SELECT FROM 1 TS B WHERE A.ID B.ID = UND ABS (B.TP)> ABS (A.TP))) COM ON C.ID = COM.ID

Answer 4

Obwohl es die Leistung verbessert, aber die Ergebnisse sind nicht korrekt.

Die Operation war ein Erfolg, aber der Patient starb.

Das Problem mit Ihrer Anfrage ist, dass

SELECT MAX(ABS(s.tp)) 
    FROM ts s INNER JOIN tc t ON s.id = t.id 
    GROUP BY s.id); 

nicht einen skalaren Wert produziert; es erzeugt eine Spalte Werte, eine für jede s.id. Ihr DBMS sollte wirklich einen Syntaxfehler verursachen. In Bezug auf die Leistung denke ich, dass Sie nacheinander jede Zeile, die von der Unterabfrage erzeugt wird, auf jede Zeile in der Zieltabelle anwenden. Es ist wahrscheinlich langsam und falsch.

Sie möchten Ihre select Ausgabe mit der Tabelle, die Sie aktualisieren, korrelieren und die Zeilen auf die korrelierten Zeilen beschränken.Hier ist die ANSI-Syntax, um eine Tabelle von einer anderen zu aktualisieren:

UPDATE calculated_table 
SET tp = (SELECT MAX(ABS(s.tp)) 
      FROM ts s INNER JOIN tc t ON s.id = t.id 
      where s.id = calculated_table.id) 
where exists (select 1 from ts join tc 
       on ts.id = tc.id 
       where ts.id = calculated_table.id) 

Das sollte in der Nähe sein, was Sie wollen.

BTW, es ist verlockend, korrelierte Unterabfragen wörtlich zu interpretieren, zu denken, dass die Unterabfrage N Mal ausgeführt wird, einmal für jede Zeile in der Zieltabelle. Und das ist der richtige Weg, es zu Bild, logisch. Das DBMS wird es jedoch wahrscheinlich nicht so implementieren, und die Leistung sollte viel besser sein als das Bild es vermuten lässt.