Średnia ruchoma w oparciu o znaczniki czasu w PostgreSQL

Question

Chciałem wykonać średnią ruchomą poprzez znaczniki czasu. Mam dwie kolumny: Temperaturę i znaczniki czasu (data-godzina) i chcę wykonać średnią ruchomą na podstawie kolejnych 15-minutowych obserwacji temperatur. Innymi słowy, wybierając dane, aby wykonać średnią na podstawie 15-minutowego przedziału czasu. Co więcej, możliwa jest różna liczba obserwacji dla różnych sekwencji czasowych. Miałem na myśli, że wszystkie rozmiary okien są równe (15 minut), ale w każdym oknie można mieć różną liczbę obserwacji. Na przykład: Dla pierwszego okna musimy obliczyć średnią z n obserwacji, a dla drugiego okna obliczyć średnią obserwacji dla obserwacji n + 5.

przykładowe dane:

 
ID Timestamps   Temperature 
1 2007-09-14 22:56:12 5.39 
2 2007-09-14 22:58:12 5.34 
3 2007-09-14 23:00:12 5.16 
4 2007-09-14 23:02:12 5.54 
5 2007-09-14 23:04:12 5.30 
6 2007-09-14 23:06:12 5.20 
7 2007-09-14 23:10:12 5.39 
8 2007-09-14 23:12:12 5.34 
9 2007-09-14 23:20:12 5.16 
10 2007-09-14 23:24:12 5.54 
11 2007-09-14 23:30:12 5.30 
12 2007-09-14 23:33:12 5.20 
13 2007-09-14 23:40:12 5.39 
14 2007-09-14 23:42:12 5.34 
15 2007-09-14 23:44:12 5.16 
16 2007-09-14 23:50:12 5.54 
17 2007-09-14 23:52:12 5.30 
18 2007-09-14 23:57:12 5.20 

Główne wyzwania:

Jak mogę dowiedzieć się kod do rozróżniania co 15 minuty, podczas gdy nie są dokładne przedziały czasowe 15 minut ze względu na różne częstotliwości próbkowania.

Answer 1

Zakładając, że chcemy, aby ponownie uruchomić średnia krocząca po upływie kolejnych 15 minut:

select id, 
     temp, 
     avg(temp) over (partition by group_nr order by time_read) as rolling_avg 
from (  
    select id, 
     temp, 
     time_read, 
     interval_group, 
     id - row_number() over (partition by interval_group order by time_read) as group_nr 
    from (
    select id, 
      time_read, 
      'epoch'::timestamp + '900 seconds'::interval * (extract(epoch from time_read)::int4/900) as interval_group, 
      temp 
    from readings 
) t1 
) t2 
order by time_read; 

jest ona oparta na Depesz's solution do grupy przez „przedziałach”:

Oto SQLFiddle przykład : http://sqlfiddle.com/#!1/0f3f0/2

Answer 2

Możesz dołączyć tabelę ze sobą:

select l1.id, avg(l2.Temperature) 
from l l1 
inner join l l2 
    on l2.id <= l1.id and 
     l2.Timestamps + interval '15 minutes' > l1.Timestamps 
group by l1.id 
order by id 
; 

Results:

| ID |   AVG | 
----------------------- 
| 1 |   5.39 | 
| 2 |   5.365 | 
| 3 | 5.296666666667 | 
| 4 |   5.3575 | 
| 5 |   5.346 | 
| 6 | 5.321666666667 | 
| 7 | 5.331428571429 | 

Wskazówka: tylko 'ciężkiej pracy' jest wykonany. Powinieneś połączyć wyniki z oryginalną tabelą lub dołączyć nowe kolumny do zapytania. Nie wiem, jakie jest twoje ostateczne zapytanie. Dostosuj to rozwiązanie lub poproś o pomoc.

Answer 3

Oto podejście, które wykorzystuje funkcję wykorzystania funkcji agregacji jako funkcji okna. Funkcja agregująca utrzymuje obserwacje z ostatnich 15 minut w tablicy wraz z bieżącą sumą bieżącą. Funkcja zmiany stanu powoduje przesunięcie elementów poza tablicę, która spadła za 15-minutowym oknem, i popycha ostatnią obserwację. Ostatnia funkcja po prostu oblicza średnią temperaturę w macierzy.

Teraz, czy to jest korzyść czy nie ... to zależy. Koncentruje się on na części programu plgpsql-postgresql, a nie na części dostępu do bazy danych, a moje własne doświadczenia wskazują, że plpgsql nie jest szybki. Jeśli możesz łatwo wykonać odnośniki z powrotem do tabeli, aby znaleźć poprzednie 15 minutowe wiersze dla każdej obserwacji, samo-łączenie (jak w odpowiedzi @danihp) będzie dobrze. Jednak takie podejście może zajmować się obserwacjami pochodzącymi z bardziej złożonego źródła, gdzie te wyszukiwania nie są praktyczne. Jak zawsze, próbuj i porównuj w swoim własnym systemie.

-- based on using this table definition 
create table observation(id int primary key, timestamps timestamp not null unique, 
         temperature numeric(5,2) not null); 

-- note that I'm reusing the table structure as a type for the state here 
create type rollavg_state as (memory observation[], total numeric(5,2)); 

create function rollavg_func(state rollavg_state, next_in observation) returns rollavg_state immutable language plpgsql as $$ 
declare 
    cutoff timestamp; 
    i int; 
    updated_memory observation[]; 
begin 
    raise debug 'rollavg_func: state=%, next_in=%', state, next_in; 
    cutoff := next_in.timestamps - '15 minutes'::interval; 
    i := array_lower(state.memory, 1); 
    raise debug 'cutoff is %', cutoff; 
    while i <= array_upper(state.memory, 1) and state.memory[i].timestamps < cutoff loop 
    raise debug 'shifting %', state.memory[i].timestamps; 
    i := i + 1; 
    state.total := state.total - state.memory[i].temperature; 
    end loop; 
    state.memory := array_append(state.memory[i:array_upper(state.memory, 1)], next_in); 
    state.total := coalesce(state.total, 0) + next_in.temperature; 
    return state; 
end 
$$; 

create function rollavg_output(state rollavg_state) returns float8 immutable language plpgsql as $$ 
begin 
    raise debug 'rollavg_output: state=% len=%', state, array_length(state.memory, 1); 
    if array_length(state.memory, 1) > 0 then 
    return state.total/array_length(state.memory, 1); 
    else 
    return null; 
    end if; 
end 
$$; 

create aggregate rollavg(observation) (sfunc = rollavg_func, finalfunc = rollavg_output, stype = rollavg_state); 

-- referring to just a table name means a tuple value of the row as a whole, whose type is the table type 
-- the aggregate relies on inputs arriving in ascending timestamp order 
select rollavg(observation) over (order by timestamps) from observation;