sélection rapide de lignes aléatoires dans Postgres

J'ai une table en postgres qui contient quelques millions de lignes. J'ai vérifié sur Internet et j'ai trouvé ce qui suit

SELECT myid FROM mytable ORDER BY RANDOM() LIMIT 1;

Cela fonctionne, mais c'est vraiment lent ... y a-t-il un autre moyen de faire cette requête, ou un moyen direct de sélectionner une ligne aléatoire sans lire toute la table? Au fait, «myid» est un entier mais il peut s'agir d'un champ vide.

Vous voudrez peut-être expérimenter OFFSET, comme dans

SELECT myid FROM mytable OFFSET floor(random()*N) LIMIT 1;

Le Nest le nombre de lignes dans mytable. Vous devrez peut-être d'abord faire un SELECT COUNT(*)pour déterminer la valeur de N.

Mise à jour (par Antony Hatchkins)

Vous devez utiliser floorici:

SELECT myid FROM mytable OFFSET floor(random()*N) LIMIT 1;

Prenons un tableau de 2 lignes; random()*Ngénère 0 <= x < 2et, par exemple, SELECT myid FROM mytable OFFSET 1.7 LIMIT 1;retourne 0 lignes en raison de l'arrondi implicite à l'entier le plus proche.

PostgreSQL 9.5 a introduit une nouvelle approche pour une sélection d'échantillons beaucoup plus rapide: TABLESAMPLE

La syntaxe est

SELECT * FROM my_table TABLESAMPLE BERNOULLI(percentage);
SELECT * FROM my_table TABLESAMPLE SYSTEM(percentage);

Ce n'est pas la solution optimale si vous ne voulez qu'une seule ligne sélectionnée, car vous devez connaître le COUNT du tableau pour calculer le pourcentage exact.

Pour éviter un COUNT lent et utiliser TABLESAMPLE rapide pour les tables de 1 ligne à des milliards de lignes, vous pouvez faire:

 SELECT * FROM my_table TABLESAMPLE SYSTEM(0.000001) LIMIT 1;
 -- if you got no result:
 SELECT * FROM my_table TABLESAMPLE SYSTEM(0.00001) LIMIT 1;
 -- if you got no result:
 SELECT * FROM my_table TABLESAMPLE SYSTEM(0.0001) LIMIT 1;
 -- if you got no result:
 SELECT * FROM my_table TABLESAMPLE SYSTEM(0.001) LIMIT 1;
 ...

Cela n'a peut-être pas l'air si élégant, mais est probablement plus rapide que toutes les autres réponses.

Pour décider si vous souhaitez utiliser BERNULLI oder SYSTEM, lisez la différence sur http://blog.2ndquadrant.com/tablesample-in-postgresql-9-5-2/

J'ai essayé cela avec une sous-requête et cela a bien fonctionné. Offset, au moins dans Postgresql v8.4.4 fonctionne très bien.

select * from mytable offset random() * (select count(*) from mytable) limit 1 ;

Vous devez utiliser floor:

SELECT myid FROM mytable OFFSET floor(random()*N) LIMIT 1;

Consultez ce lien pour différentes options. http://www.depesz.com/index.php/2007/09/16/my-ought-on-getting-random-row/

Mettre à jour: (A. Hatchkins)

Le résumé de l'article (très) long est le suivant.

L'auteur énumère quatre approches:

1) ORDER BY random() LIMIT 1; - lent

2) ORDER BY id where id>=random()*N LIMIT 1- non uniforme s'il y a des lacunes

3) colonne aléatoire - doit être mise à jour de temps en temps

4) agrégat aléatoire personnalisé - méthode astucieuse, peut être lente: random () doit être généré N fois

et suggère d'améliorer la méthode n ° 2 en utilisant

5) ORDER BY id where id=random()*N LIMIT 1 avec des requêtes ultérieures si le résultat est vide.

Le moyen le plus simple et le plus rapide de récupérer une ligne aléatoire est d'utiliser l' tsm_system_rowsextension:

CREATE EXTENSION IF NOT EXISTS tsm_system_rows;

Ensuite, vous pouvez sélectionner le nombre exact de lignes que vous souhaitez:

SELECT myid  FROM mytable TABLESAMPLE SYSTEM_ROWS(1);

Ceci est disponible avec PostgreSQL 9.5 et versions ultérieures.

Voir: https://www.postgresql.org/docs/current/static/tsm-system-rows.html

Je suis venu avec une solution très rapide sans TABLESAMPLE. Beaucoup plus rapide que OFFSET random()*N LIMIT 1. Il ne nécessite même pas de compte de table.

L'idée est de créer un index d'expression avec des données aléatoires mais prévisibles, par exemple md5(primary key).

Voici un test avec des exemples de données de 1M lignes:

create table randtest (id serial primary key, data int not null);

insert into randtest (data) select (random()*1000000)::int from generate_series(1,1000000);

create index randtest_md5_id_idx on randtest (md5(id::text));

explain analyze
select * from randtest where md5(id::text)>md5(random()::text)
order by md5(id::text) limit 1;

Résultat:

 Limit  (cost=0.42..0.68 rows=1 width=8) (actual time=6.219..6.220 rows=1 loops=1)
   ->  Index Scan using randtest_md5_id_idx on randtest  (cost=0.42..84040.42 rows=333333 width=8) (actual time=6.217..6.217 rows=1 loops=1)
         Filter: (md5((id)::text) > md5((random())::text))
         Rows Removed by Filter: 1831
 Total runtime: 6.245 ms

Cette requête peut parfois (avec une probabilité d'environ 1 / Number_of_rows) renvoyer 0 ligne, elle doit donc être vérifiée et réexécutée. De plus, les probabilités ne sont pas exactement les mêmes - certaines lignes sont plus probables que d'autres.

En comparaison:

explain analyze SELECT id FROM randtest OFFSET random()*1000000 LIMIT 1;

Les résultats varient considérablement, mais peuvent être assez mauvais:

 Limit  (cost=1442.50..1442.51 rows=1 width=4) (actual time=179.183..179.184 rows=1 loops=1)
   ->  Seq Scan on randtest  (cost=0.00..14425.00 rows=1000000 width=4) (actual time=0.016..134.835 rows=915702 loops=1)
 Total runtime: 179.211 ms
(3 rows)