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

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

• criará um número aleatório para cada linha. O número está entre 0 e 1
• ele avalia se deve mostrar essa linha se o número gerado está entre 0 e .3 (30%).

• Isto é O(n) mas não é necessária nenhuma ordenação por isso é mais rápido que o o (n lg n)
• O Mysql é muito capaz de gerar números aleatórios para cada linha. Tenta isto.

  Selecione rand () de INFORMATION_SCHEMA.Limite das tabelas 10;

Mais rápido que a ordem de RAND ()

Eu testei este método para ser muito mais rápido do que {[[2]}, por isso ele funciona em o(n) tempo, e faz isso impressionantemente rápido.

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

Non-MSSQL version -- I did not test this

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)

Isto irá seleccionar ~1% dos registos. Por isso, se precisar de um número exacto de percentagens ou registos a seleccionar, estimar a sua percentagem com alguma margem de segurança e, em seguida, arrancar aleatoriamente os registos de excesso do conjunto resultante, usando o método mais caro ORDER BY RAND().

Ainda Mais Rápido

Por exemplo, se tiver uma coluna indexada com inteiros uniformemente distribuídos [0..max], você pode usar isso para selecionar aleatoriamente N pequenos intervalos. Faça isso dinamicamente em seu programa para obter um diferente definir para cada pesquisa executada. Esta seleção de subconjuntos será o (n) , que pode muitas ordens de magnitude menor do que o seu conjunto completo de dados.

No meu teste reduzi o tempo necessário para obter 20 (20 mil) registos de amostras de 3 minutos usando a ordem de RAND () para 0, 0 segundos!

Aparentemente em algumas versões do SQL há um comando {[[0]}, mas não está em todas as implementações do SQL (notavelmente, Redshift).

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

Usa apenas

WHERE RAND() < 0.1 

Para obter 10% dos registos ou

WHERE RAND() < 0.01 

Para obter 1% dos registos, etc.

Começando com a observação de que podemos recuperar os ids de uma tabela (por exemplo. Contagem 5) com base num conjunto:

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

Podemos chegar ao resultado de que se pudéssemos gerar a cadeia "(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 os ids têm lacunas, então o arraylist inicial indices é o resultado de uma consulta sql sobre ids.

Se precisar exactamente m linhas, realisticamente irá gerar o seu subconjunto de IDs fora do SQL. A maioria dos métodos requerem em algum ponto para selecionar a entrada "nth", e tabelas SQL realmente não são arrays em tudo. A suposição de que as chaves são consecutivas, a fim de apenas juntar ints aleatórios entre 1 e a contagem também é difícil de satisfazer - MySQL por exemplo não suporta nativamente, e as condições de bloqueio são... Complicado.

1. obtenha todos os valores da coluna-chave da tabela de dados em qualquer ordem para uma lista na sua linguagem de programação favorita em O(n)
2. execute um baralhar Fisher-Yates , parando depois de swaps m, e extraia o subarray [0:m-1] em ϴ(m)
3. "juntar" o subarray com o conjunto de dados original (por exemplo SELECT ... WHERE id IN (<subarray>)) em O(m lg n)

Qualquer método que gera o subconjunto Aleatório fora da SQL deve ter pelo menos isto complexidade. A junção não pode ser mais rápida do que O(m lg n) com o BTREE (então O(m) reivindicações são Fantasia para a maioria dos motores) e a baralha é limitada abaixo de n e m lg n e não afeta o comportamento assintótico.

Em pseudocódigo Pythónico:

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

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