Talvez você poderia fazer

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

Apenas use

WHERE RAND() < 0.1 

para obter 10% dos registros ou

WHERE RAND() < 0.01 

para obter 1% dos registros, etc.

Acho que a solução mais rápida é

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

Aqui é por isso que eu acho que isso deve fazer o trabalho.

• Ele vai criar um número aleatório para cada linha. O número situa-se entre 0 e 1
• Ele avalia se deve exibir essa linha se o número gerado é entre 0 e 0,3 (30%).

Isto assume que rand () é a geração de números de uma distribuição uniforme. É a maneira mais rápida de fazer isso.

Eu vi que alguém tinha recomendado essa solução e eles ficou abatido sem prova .. aqui é o que eu diria a isso -

• Este é O (n), mas nenhuma classificação é necessária por isso, é mais rápido do que o S (n lg n)

• mysql é muito capaz de gerar números aleatórios para cada linha. Tente isto -

  seleccionar rand () INFORMATION_SCHEMA.TABLES de limite 10;

Desde que o banco de dados em questão é mySQL, esta é a solução certa.

Começando com a observação de que podemos recuperar os ids de uma tabela (. Por exemplo, contar 5) com base em um conjunto:

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

podemos chegar ao resultado que, se pudéssemos gerar a string "(4, 1, 2, 5, 3)", então teríamos uma maneira mais eficiente do que RAND().

Por exemplo, em 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(']', ')');

Se ids têm lacunas, em seguida, o ArrayList inicial indicesé o resultado de uma consulta SQL em ids.

Aparentemente, em algumas versões do SQL há um TABLESAMPLEcomando, mas não é em todas as implementações de SQL (nomeadamente, Redshift).

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

Quero salientar que todas essas soluções parecem provar sem substituição. Selecionar as linhas superiores K a partir de um tipo aleatório ou aderir a uma tabela que contém chaves únicas em ordem aleatória irá produzir uma amostra aleatória gerada sem substituição.

Se você quiser que o seu exemplo para ser independente, você precisa provar com a substituição. Veja Pergunta 25451034 para um exemplo de como fazer isso usando um JOIN de uma maneira semelhante à solução das user12861. A solução é escrito para T-SQL, mas o conceito funciona em qualquer db SQL.

Faster Than ORDER BY RAND ()

Testei este método seja muito mais rápido do que ORDER BY RAND(), por conseguinte, que é executado em O (n) de tempo, e fá-lo de forma impressionante rápido.

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

Versão não-MSSQL - Eu não testei este

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

versão MSSQL:

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

Isso irá selecionar ~ 1% dos registros. Então, se você precisa exata # de porcentagens ou registros a ser selecionado, estimar o percentual com alguma margem de segurança, então arrancar aleatoriamente registros excesso de resultando set, usando o mais caro ORDER BY RAND()método.

Ainda mais rápido

I foi capaz de melhorar esse método ainda mais porque tinha um intervalo de valores coluna indexada bem conhecido.

Por exemplo, se tiver uma coluna indexada com números inteiros uniformemente distribuídos [0..max], pode utilizar que para seleccionar aleatoriamente N pequenos intervalos. Faça isso de forma dinâmica no seu programa para obter um conjunto diferente para cada execução da consulta. Esta seleção subconjunto será O (N) , que pode muitas ordens de magnitude menor do que o conjunto de dados completo.

No meu teste eu reduziu o tempo necessário para obter 20 (fora 20 mil) registros de amostra de 3 minutos utilizando ORDER BY RAND () até 0,0 segundos !

Se você precisar exatamente mlinhas, realisticamente você vai gerar seu subconjunto de IDs fora do SQL. A maioria dos métodos exigem em algum ponto para selecionar a entrada "enésimo", e tabelas SQL realmente não são matrizes em tudo. A suposição de que as chaves são consecutivos, a fim de juntar-se apenas ints aleatórios entre 1 e a contagem também é difícil de satisfazer - MySQL, por exemplo, não o suporta nativamente, e as condições de bloqueio são ... complicado .

Aqui está um O(max(n, m lg n))-time, O(n)solução -espaço assumindo chaves BTREE apenas simples:

1. Obtêm todos os valores da coluna de chave da tabela de dados em qualquer ordem em uma matriz em sua linguagem de programação favorita em O(n)
2. Executar uma Shuffle Fisher-Yates , parando depois de mswaps, e extrair o subarray [0:m-1]emϴ(m)
3. "Junte-se" o subarray com o conjunto de dados originais (por exemplo SELECT ... WHERE id IN (<subarray>)) emO(m lg n)

Qualquer método que gera o subconjunto aleatório fora do SQL tem de ter, pelo menos, esta complexidade. A junção não pode ser qualquer mais rápido do que O(m lg n)com BTREE (assim O(m)reivindicações são fantasia para a maioria dos motores) e o shuffle é delimitada abaixo ne m lg ne não afeta o comportamento assintótica.

Em pseudocódigo Pythonic:

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])

Selecione 3000 registros aleatórios em Netezza:

WITH IDS AS (
     SELECT ID
     FROM MYTABLE;
)

SELECT ID FROM IDS ORDER BY mt_random() LIMIT 3000