GROUPE PAR intervalle d'horodatage 10 minutes PostgreSQL [fermé]

10

Je dois grouper par une période de temps se séparant de 10 minutes.

J'ai cette requête ci-dessous qui me renvoie un ensemble de résultats:

SELECT timestamp
    FROM table_1, table_2_shape_polygon
    WHERE ST_Within(earthnetworks_geometry_raios, poligono_geometry)
      AND timestamp 
      BETWEEN '2013-04-07 15:30:00' AND '2013-04-07 16:50:00'
      AND type = 0
      AND id_polygon = 2

Mon jeu de résultats est comme ceci:

"2013-04-07 15:30:55"
"2013-04-07 15:32:52"
"2013-04-07 15:32:52"
"2013-04-07 15:34:21"
"2013-04-07 15:39:09"
"2013-04-07 16:24:25"
"2013-04-07 16:29:58"
"2013-04-07 16:33:22"
"2013-04-07 16:34:30"
"2013-04-07 16:35:09"
"2013-04-07 16:36:54"
"2013-04-07 16:38:40"
"2013-04-07 16:39:37"
"2013-04-07 16:39:37"
"2013-04-07 16:39:38"
"2013-04-07 16:39:38"
"2013-04-07 16:39:44"
"2013-04-07 16:39:56"
"2013-04-07 16:40:03"
"2013-04-07 16:40:04"
"2013-04-07 16:41:22"
"2013-04-07 16:41:27"
"2013-04-07 16:41:38"
"2013-04-07 16:41:38"
"2013-04-07 16:42:24"
"2013-04-07 16:42:39"
"2013-04-07 16:45:00"
"2013-04-07 16:45:40"
"2013-04-07 16:49:43"

J'ai tous les horodatages entre une période, mais je dois les regrouper toutes les 10 minutes et je ne sais pas comment. J'ai essayé date_truncce qui n'a pas la précision dont j'ai besoin.

ex: entre 2013-04-07 15:30:00, 2013-04-07 15:40:00 5 results.

Comment puis-je faire ceci?

J'ai essayé cela et cela n'a pas fonctionné comme prévu.

SELECT
    timestamp 'epoch' +
    INTERVAL '1 second' * round((extract('epoch' from earthnetworks_dt_horario) / 600) * 600) as horario,
    count(earthnetworks_dt_horario)
FROM raios.earthnetworks, raios.earthnetworks_teste_poligono
WHERE ST_Within(earthnetworks_geometry_raios, poligono_geometry)
      AND earthnetworks_dt_horario 
      BETWEEN '2013-04-07 15:30:00' AND '2013-04-07 16:50:00'
      AND earthnetworks_num_tipo = 0
      AND id_poligono = 2
GROUP BY 
round(extract('epoch' from earthnetworks_dt_horario) / 600), earthnetworks_dt_horario

Il s'agit du jeu de résultats non groupé:

"2013-04-07 16:29:58";1
"2013-04-07 16:34:30";1
"2013-04-07 16:33:22";1
"2013-04-07 16:39:44";1
"2013-04-07 16:39:56";1
"2013-04-07 16:42:24";1
"2013-04-07 16:41:38";2
"2013-04-07 16:24:25";1
"2013-04-07 16:39:38";2
"2013-04-07 16:42:39";1
"2013-04-07 16:41:27";1
"2013-04-07 16:36:54";1
"2013-04-07 16:45:00";1
"2013-04-07 16:40:04";1
"2013-04-07 16:40:03";1
"2013-04-07 15:34:21";1
"2013-04-07 15:30:55";1
"2013-04-07 15:39:09";1
"2013-04-07 16:49:43";1
"2013-04-07 16:45:40";1
"2013-04-07 16:35:09";1
"2013-04-07 16:38:40";1
"2013-04-07 16:39:37";2
"2013-04-07 16:41:22";1
"2013-04-07 15:32:52";2

Cela n'a pas fonctionné.

postgresql grouping Marco Amaral
la source

Réponses:

14

Vous pouvez l'utiliser pour PostgreSQL. 600 est de 10 minutes en secondes. L'idée est de convertir l'horodatage en époque, diviser par intervalle souhaité en minutes puis arrondir pour obtenir l'intervalle souhaité

SELECT COUNT(*) cnt, 
to_timestamp(floor((extract('epoch' from timestamp_column) / 600 )) * 600) 
AT TIME ZONE 'UTC' as interval_alias
FROM TABLE_NAME GROUP BY interval_alias
Nestor Martinez
la source
2

vous pouvez utiliser cette réponse en remplaçant 300 par 600 (le nombre de secondes en 10 minutes)

geogeek
la source
2

Il existe quelques fonctions datetime pratiques . Tout d'abord, déconstruisez les horodatages avec date_truncà chaque heure, puis effectuez une division entière avec les minutes avec date_partpour créer un intervalle, qui est recombiné.

SELECT COUNT(*), 
    date_trunc('hour', timestamp) +
    (((date_part('minute', ts)::integer / 10::integer) * 10::integer)
     || ' minutes')::interval AS ten_min_timestamp
FROM sometable_or_joins_or_whatever
GROUP BY ten_min_timestamp;
Mike T
la source
Cela fonctionne bien avec toutes les conditions, doit avoir été voté. Mais je ne sais pas pourquoi || ' minutes'a été utilisé dans date_part.
Vishal Shetty
integer || 'minutes'est utilisé pour créer un type d'intervalle, par exemple "8 minutes", qui est ajouté à l'horodatage.
Mike T du
1

J'ai fait quelque chose de similaire dans mySql en les regroupant par horodatage - MOD(timestamp, 600), dont la valeur de retour sera la même pour tous les horodatages dans un intervalle de 10 min (600 sec).

Johan Kuylenstierna
la source