[PL/SQL] Trasformare un sorgente Sql per il rolling in Pl/Sql

[Dalton]

Ciao a tutti, vorrei trasformare un calcolo rolling sviluppato in sql in una procedura pl/sql.
Nel dettaglio, presa una tabella composta da due campi, data e valore numerico, ottengo un terzo campo, risultato della media dei 6 giorni precedenti a quello considerato + quest'ultimo (il calcolo non lo effettuo per i primi sette giorni):

DAYS	TOT	ROLLING
		
01-set	9	0
03-ago	0	0
04-ago	2	0
05-ago	4	0
06-ago	5	0
07-ago	5	0
08-ago	0	4
09-ago	0	2
10-ago	3	3
11-ago	6	3
12-ago	2	3
13-ago	4	3
14-ago	0	2
15-ago	0	2
16-ago	0	2
17-ago	4	2
18-ago	4	2
19-ago	0	2
20-ago	3	2
21-ago	2	2
22-ago	2	2
23-ago	0	2
24-ago	6	2
25-ago	8	3
26-ago	4	4
27-ago	6	4
28-ago	3	4
29-ago	0	4
30-ago	0	4
31-ago	9	4

Il codice utilizzato è il seguente:

SELECT tot.days, tot.ripetuti as tot,
          CASE
             WHEN ROWNUM = 7
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 0
                                                      AND ROWNUM < 8
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 8
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 1
                                                      AND ROWNUM < 9
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 9
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 2
                                                 AND ROWNUM < 10
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 10
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 3
                                                 AND ROWNUM < 11
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 11
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 4
                                                 AND ROWNUM < 12
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 12
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 5
                                                 AND ROWNUM < 13
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx

[Dalton]

FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 13
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 6
                                                 AND ROWNUM < 14
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 14
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 7
                                                 AND ROWNUM < 15
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 15
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 8
                                                 AND ROWNUM < 16
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 16
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 9
                                                 AND ROWNUM < 17
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 17
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 10
                                                 AND ROWNUM < 18
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 18
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 11
                                                 AND ROWNUM < 19
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 19
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 12
                                                 AND ROWNUM < 20
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 20
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 13
                                                 AND ROWNUM < 21
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 21
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 14
                                                 AND ROWNUM < 22
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 22
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 15
                                                 AND ROWNUM < 23
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 23
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 16
                                                 AND ROWNUM < 24
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 24
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 17
                                                 AND ROWNUM < 25
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 25
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 18
                                                 AND ROWNUM < 26
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 26
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 19
                                                 AND ROWNUM < 27
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 27
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 20
                                                 AND ROWNUM < 28
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 28
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 21
                                                 AND ROWNUM < 29
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 29
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 22
                                                 AND ROWNUM < 30
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             WHEN ROWNUM = 30
                THEN (SELECT xx
                        FROM (SELECT ROUND
                                        (AVG (CASE
                                                 WHEN ROWNUM > 23
                                                 AND ROWNUM < 31
                                                    THEN ripetuti
                                              END
                                             ),
                                         0
                                        ) AS xx
                                FROM totale.tot)
                       WHERE xx IS NOT NULL)
             ELSE 0
          END AS rolling
     FROM totale.tot

Vorrei portare il tutto in una procedura che sicuramente non richiedera' tutto sto codice ma con due for credo si risolva. Purtroppo non sono in grado di generarla, e proprio per questo spero di trovare un anima pia che mi aiuti e mi illumini un pò. Come potete vedere il risultato che voglio gia' lo ottengo. Grazie a tutti ciao!

[Dalton]

La mia idea era la seguente:

var
cursore,intero,j,i:integer;

cursore:=8
  for j:=8 to 31 do
    begin 
      for i:=0 to 6 do
          intero:=intero+valore[cursore-i];
  valore[cursore]=intero\7;
  cursore:=cursore+1;
end;

Come lo trasformo in pl/sql?

[LeleFT]

Come espressamente indicato nel regolamento interno, quando si posta del codice vanno usati i tag CODE, per renderlo più leggibile.

Inoltre, il titolo andrebbe scelto con cura.

Modifico i tuoi post precedenti e il titolo.


Ciao.