je pense que la solution la plus rapide est

select * from table where rand() <= .3

Voici pourquoi je pense que cela devrait faire l'affaire.

• il créera un nombre aléatoire pour chaque ligne. Le nombre est entre 0 et 1
• il évalue s'il faut afficher cette ligne si le nombre généré est entre 0 et .3 (30%).

cela suppose que rand() génère des nombres dans une distribution uniforme. C'est le le moyen le plus rapide pour ce faire.

j'ai vu que quelqu'un avait recommandé Cette solution et ils ont été abattus sans preuve.. voici ce que je dirais -

• C'est O(n), mais aucun tri n'est requis, donc il est plus rapide que le O(N lg n)

• mysql est très capable de générer des nombres aléatoires pour chaque ligne. Essayez ceci -

  sélectionnez rand() à partir de INFORMATION_SCHEMA.Tableaux limite 10;

comme la base de données en question Est mySQL, c'est la bonne solution.

plus rapide que L'ordre de RAND ()

j'ai testé cette méthode pour être beaucoup plus rapide que ORDER BY RAND() , donc il fonctionne dans O(n) temps, et fait si impressionnant rapide.

de http://technet.microsoft.com/en-us/library/ms189108%28v=sql.105%29.aspx :

Non-MSSQL version -- Je n'ai pas testé ce

SELECT * FROM Sales.SalesOrderDetail
WHERE 0.01 >= RAND()

Version MSSQL:

SELECT * FROM Sales.SalesOrderDetail
WHERE 0.01 >= CAST(CHECKSUM(NEWID(), SalesOrderID) & 0x7fffffff AS float) / CAST (0x7fffffff AS int)

cela sélectionnera ~1% des enregistrements. Donc, si vous avez besoin du nombre exact de percents ou des enregistrements pour être sélectionné, estimez votre pourcentage avec une certaine marge de sécurité, puis plumer au hasard des enregistrements excédentaires de l'ensemble résultant, en utilisant la méthode plus coûteuse ORDER BY RAND() .

Encore Plus Rapide

j'ai été en mesure d'améliorer encore plus sur cette méthode parce que j'ai eu une gamme bien connue de valeur de colonne indexée.

par exemple, si vous avez une colonne indexée avec des entiers uniformément répartis [0..max], vous pouvez l'utiliser pour sélectionner au hasard N petits intervalles. Faites cela dynamiquement dans votre programme pour obtenir un ensemble différent pour chaque requête exécutée. Cette sélection de sous-ensemble sera O (N) , qui peut être de plusieurs ordres de grandeur plus petit que votre ensemble de données complet.

dans mon test j'ai réduit le temps nécessaire pour obtenir 20 (sur 20 mil) enregistrements d'échantillon de 3 minutes sur commande de RAND () jusqu'à 0,0 secondes !

apparemment dans certaines versions de SQL il y a une commande TABLESAMPLE , mais ce n'est pas dans toutes les implémentations de SQL (notamment Redshift).

http://technet.microsoft.com/en-us/library/ms189108 (v=sql.105).aspx

il suffit d'utiliser

WHERE RAND() < 0.1 

pour obtenir 10% des enregistrements ou

WHERE RAND() < 0.01 

pour obtenir 1% des enregistrements, etc.

en commençant par l'observation que nous pouvons récupérer les ID d'une table (par ex. count 5) basé sur un ensemble:

select *
from table_name
where _id in (4, 1, 2, 5, 3)

nous pouvons en arriver au résultat que si nous pouvions générer la chaîne "(4, 1, 2, 5, 3)" , alors nous aurions un moyen plus efficace que RAND() .

par exemple, en Java:

ArrayList<Integer> indices = new ArrayList<Integer>(rowsCount);
for (int i = 0; i < rowsCount; i++) {
    indices.add(i);
}
Collections.shuffle(indices);
String inClause = indices.toString().replace('[', '(').replace(']', ')');

si les ids ont des trous, alors le premier arraylist indices est le résultat d'une requête sql sur les ids.

je tiens à souligner que toutes ces solutions semblent échantillonnage sans remplacement. En sélectionnant les lignes K supérieures à partir d'un tri aléatoire ou en se joignant à une table qui contient des Clés uniques dans l'ordre aléatoire vous obtiendrez un échantillon aléatoire généré sans remplacement.

si vous voulez que votre échantillon soit indépendant, vous aurez besoin d'échantillon avec remplacement. Voir Question 25451034 pour un exemple de la façon d'utiliser une jointure d'une manière similaire à la solution de user12861. La solution est écrite pour T-SQL, mais le concept fonctionne dans N'importe quel db SQL.

si vous avez besoin exactement des lignes m , il est réaliste de penser que vous allez générer votre sous-ensemble D'IDs en dehors de SQL. La plupart des méthodes exigent à un certain point pour sélectionner la" nth " entrée, et les tables SQL ne sont vraiment pas des tableaux du tout. La supposition que les touches sont consécutives afin de simplement joindre les ints aléatoires entre 1 et le nombre est également difficile à satisfaire - MySQL par exemple ne supporte pas nativement, et les conditions de serrure sont... tricky .

voici un O(max(n, m lg n)) - temps, O(n) - solution spatiale en supposant des clés BTREE simples:

1. Récupérer toutes les valeurs de la colonne de la clé de la table de données dans n'importe quel ordre dans un tableau dans votre langage de script favori dans O(n)
2. effectuer un Fisher-Yates shuffle , s'arrêtant après m swaps, et extraire le subarray [0:m-1] dans ϴ(m) 1519220920"
3. "Rejoindre" la subarray avec l'ensemble de données d'origine (par exemple SELECT ... WHERE id IN (<subarray>) ) dans O(m lg n)

toute méthode qui génère le sous-ensemble aléatoire en dehors de SQL doit avoir au moins cette complexité. La jointure ne peut pas être plus rapide que O(m lg n) avec BTREE (donc les revendications O(m) sont fantastiques pour la plupart des moteurs) et le mélange est limité en dessous de n et m lg n et n'affecte pas le comportement asymptotique.

en pseudo-code pythonique:

ids = sql.query('SELECT id FROM t')
for i in range(m):
  r = int(random() * (len(ids) - i))
  ids[i], ids[i + r] = ids[i + r], ids[i]

results = sql.query('SELECT * FROM t WHERE id IN (%s)' % ', '.join(ids[0:m-1])

peut-être que tu pourrais faire

SELECT * FROM table LIMIT 10000 OFFSET FLOOR(RAND() * 190000)