Utilizzando PostgreSQL (8.4), sto creando una vista che riassume i vari risultati di pochi tavoli (per esempio la creazione di colonne a, b, cnella vista), e poi ho bisogno di combinare alcuni di questi risultati insieme nella stessa query (ad esempio a+b, a-b, (a+b)/c, ...), in modo da produrre i risultati finali. Quello che sto notando è che i risultati intermedi vengono calcolati completamente ogni volta che vengono utilizzati, anche se vengono eseguiti all'interno della stessa query.
C'è un modo per ottimizzarlo in modo da evitare che gli stessi risultati vengano calcolati ogni volta?
Ecco un esempio semplificato che riproduce il problema.
CREATE TABLE test1 (
id SERIAL PRIMARY KEY,
log_timestamp TIMESTAMP NOT NULL
);
CREATE TABLE test2 (
test1_id INTEGER NOT NULL REFERENCES test1(id),
category VARCHAR(10) NOT NULL,
col1 INTEGER,
col2 INTEGER
);
CREATE INDEX test_category_idx ON test2(category);
-- Added after edit to this question
CREATE INDEX test_id_idx ON test2(test1_id);
-- Populating with test data.
INSERT INTO test1(log_timestamp)
SELECT * FROM generate_series('2011-01-01'::timestamp, '2012-01-01'::timestamp, '1 hour');
INSERT INTO test2
SELECT id, substr(upper(md5(random()::TEXT)), 1, 1),
(20000*random()-10000)::int, (3000*random()-200)::int FROM test1;
INSERT INTO test2
SELECT id, substr(upper(md5(random()::TEXT)), 1, 1),
(2000*random()-1000)::int, (3000*random()-200)::int FROM test1;
INSERT INTO test2
SELECT id, substr(upper(md5(random()::TEXT)), 1, 1),
(2000*random()-40)::int, (3000*random()-200)::int FROM test1;Ecco una vista che esegue le operazioni che richiedono più tempo:
CREATE VIEW testview1 AS
SELECT
t1.id,
t1.log_timestamp,
(SELECT SUM(t2.col1) FROM test2 t2 WHERE t2.test1_id=t1.id AND category='A') AS a,
(SELECT SUM(t2.col2) FROM test2 t2 WHERE t2.test1_id=t1.id AND category='B') AS b,
(SELECT SUM(t2.col1 - t2.col2) FROM test2 t2 WHERE t2.test1_id=t1.id AND category='C') AS c
FROM test1 t1;SELECT a FROM testview1produce questo piano (viaEXPLAIN ANALYZE):Seq Scan on test1 t1 (cost=0.00..1787086.55 rows=8761 width=4) (actual time=12.877..10517.575 rows=8761 loops=1) SubPlan 1 -> Aggregate (cost=203.96..203.97 rows=1 width=4) (actual time=1.193..1.193 rows=1 loops=8761) -> Bitmap Heap Scan on test2 t2 (cost=36.49..203.95 rows=1 width=4) (actual time=1.109..1.177 rows=0 loops=8761) Recheck Cond: ((category)::text = 'A'::text) Filter: (test1_id = $0) -> Bitmap Index Scan on test_category_idx (cost=0.00..36.49 rows=1631 width=0) (actual time=0.414..0.414 rows=1631 loops=8761) Index Cond: ((category)::text = 'A'::text) Total runtime: 10522.346 ms
SELECT a, a FROM testview1produce questo piano :Seq Scan on test1 t1 (cost=0.00..3574037.50 rows=8761 width=4) (actual time=3.343..20550.817 rows=8761 loops=1) SubPlan 1 -> Aggregate (cost=203.96..203.97 rows=1 width=4) (actual time=1.183..1.183 rows=1 loops=8761) -> Bitmap Heap Scan on test2 t2 (cost=36.49..203.95 rows=1 width=4) (actual time=1.100..1.166 rows=0 loops=8761) Recheck Cond: ((category)::text = 'A'::text) Filter: (test1_id = $0) -> Bitmap Index Scan on test_category_idx (cost=0.00..36.49 rows=1631 width=0) (actual time=0.418..0.418 rows=1631 loops=8761) Index Cond: ((category)::text = 'A'::text) SubPlan 2 -> Aggregate (cost=203.96..203.97 rows=1 width=4) (actual time=1.154..1.154 rows=1 loops=8761) -> Bitmap Heap Scan on test2 t2 (cost=36.49..203.95 rows=1 width=4) (actual time=1.083..1.143 rows=0 loops=8761) Recheck Cond: ((category)::text = 'A'::text) Filter: (test1_id = $0) -> Bitmap Index Scan on test_category_idx (cost=0.00..36.49 rows=1631 width=0) (actual time=0.426..0.426 rows=1631 loops=8761) Index Cond: ((category)::text = 'A'::text) Total runtime: 20557.581 ms
Qui, la selezione a, arichiede il doppio della selezione a, mentre potrebbero essere realmente calcolati una sola volta. Ad esempio, con SELECT a, a+b, a-b FROM testview1, passa attraverso il sotto-piano per a3 volte e bdue volte, mentre il tempo di esecuzione potrebbe essere ridotto a 2/5 del tempo totale (supponendo che + e - siano trascurabili qui).
È una buona cosa che non calcoli le colonne inutilizzate ( be c) quando non sono necessarie, ma c'è un modo per farlo calcolare le stesse colonne usate dalla vista solo una volta?
EDIT: @Frank Heikens ha suggerito correttamente di utilizzare un indice, che mancava nell'esempio sopra. Mentre migliora la velocità per ciascun sotto-piano, non impedisce che la stessa sottoquery venga calcolata più volte. Mi dispiace, avrei dovuto inserirlo nella domanda iniziale per chiarire.