Selecione n linhas aleatórias da tabela do SQL Server

Eu tenho uma tabela do SQL Server com cerca de 50.000 linhas. Quero selecionar cerca de 5.000 dessas linhas aleatoriamente. Eu pensei em uma maneira complicada, criando uma tabela temporária com uma coluna "número aleatório", copiando minha tabela para isso, percorrendo a tabela temporária e atualizando cada linha com RAND()e selecionando nessa tabela onde a coluna de número aleatório < 0.1 Estou procurando uma maneira mais simples de fazer isso, em uma única declaração, se possível.

Este artigo sugere o uso da NEWID()função Parece promissor, mas não vejo como selecionar de maneira confiável uma certa porcentagem de linhas.

Alguém já fez isso antes? Alguma ideia?

select top 10 percent * from [yourtable] order by newid()

Em resposta ao comentário "lixo puro" sobre tabelas grandes: você pode fazer assim para melhorar o desempenho.

select  * from [yourtable] where [yourPk] in 
(select top 10 percent [yourPk] from [yourtable] order by newid())

O custo disso será a varredura principal dos valores mais o custo da junção, que em uma tabela grande com uma pequena seleção percentual deve ser razoável.

Dependendo das suas necessidades, TABLESAMPLEvocê terá desempenho quase tão aleatório e melhor. isso está disponível no MS SQL Server 2005 e posterior.

TABLESAMPLE retornará dados de páginas aleatórias em vez de linhas aleatórias e, portanto, nem recupera os dados que não retornará.

Em uma mesa muito grande eu testei

select top 1 percent * from [tablename] order by newid()

demorou mais de 20 minutos.

select * from [tablename] tablesample(1 percent)

demorou 2 minutos.

O desempenho também melhorará em amostras menores, TABLESAMPLEenquanto isso não ocorrerá newid().

Lembre-se de que isso não é tão aleatório quanto o newid()método, mas fornecerá uma amostra decente.

Veja a página do MSDN .

newid () / order by funcionará, mas será muito caro para grandes conjuntos de resultados porque ele precisa gerar um ID para cada linha e, em seguida, classificá-los.

TABLESAMPLE () é bom do ponto de vista de desempenho, mas você obterá agrupamentos de resultados (todas as linhas em uma página serão retornadas).

Para uma amostra aleatória verdadeira com melhor desempenho, a melhor maneira é filtrar as linhas aleatoriamente. Encontrei o seguinte exemplo de código no artigo Manuais Online do SQL Server Limitando conjuntos de resultados usando TABLESAMPLE :

Se você realmente deseja uma amostra aleatória de linhas individuais, modifique sua consulta para filtrar linhas aleatoriamente, em vez de usar TABLESAMPLE. Por exemplo, a consulta a seguir usa a função NEWID para retornar aproximadamente um por cento das linhas da tabela Sales.SalesOrderDetail:

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

A coluna SalesOrderID está incluída na expressão CHECKSUM para que NEWID () avalie uma vez por linha para obter amostragem por linha. A expressão CAST (CHECKSUM (NEWID (), SalesOrderID) & 0x7fffffff AS float / CAST (0x7fffffff AS int) é avaliada como um valor flutuante aleatório entre 0 e 1.

Quando executado em uma tabela com 1.000.000 de linhas, eis meus resultados:

SET STATISTICS TIME ON
SET STATISTICS IO ON

/* newid()
   rows returned: 10000
   logical reads: 3359
   CPU time: 3312 ms
   elapsed time = 3359 ms
*/
SELECT TOP 1 PERCENT Number
FROM Numbers
ORDER BY newid()

/* TABLESAMPLE
   rows returned: 9269 (varies)
   logical reads: 32
   CPU time: 0 ms
   elapsed time: 5 ms
*/
SELECT Number
FROM Numbers
TABLESAMPLE (1 PERCENT)

/* Filter
   rows returned: 9994 (varies)
   logical reads: 3359
   CPU time: 641 ms
   elapsed time: 627 ms
*/    
SELECT Number
FROM Numbers
WHERE 0.01 >= CAST(CHECKSUM(NEWID(), Number) & 0x7fffffff AS float) 
              / CAST (0x7fffffff AS int)

SET STATISTICS IO OFF
SET STATISTICS TIME OFF

Se você conseguir usar o TABLESAMPLE, ele fornecerá o melhor desempenho. Caso contrário, use o método newid () / filter. newid () / order by deve ser o último recurso se você tiver um grande conjunto de resultados.

A seleção aleatória de linhas de uma tabela grande no MSDN possui uma solução simples e bem articulada que trata das preocupações de desempenho em larga escala.

  SELECT * FROM Table1
  WHERE (ABS(CAST(
  (BINARY_CHECKSUM(*) *
  RAND()) as int)) % 100) < 10

Este link tem uma comparação interessante entre Orderby (NEWID ()) e outros métodos para tabelas com 1, 7 e 13 milhões de linhas.

Freqüentemente, quando perguntas sobre como selecionar linhas aleatórias são feitas em grupos de discussão, a consulta NEWID é proposta; é simples e funciona muito bem para pequenas mesas.

SELECT TOP 10 PERCENT *
  FROM Table1
  ORDER BY NEWID()

No entanto, a consulta NEWID tem uma grande desvantagem quando você a usa para tabelas grandes. A cláusula ORDER BY faz com que todas as linhas da tabela sejam copiadas no banco de dados tempdb, onde são classificadas. Isso causa dois problemas:

1. A operação de classificação geralmente tem um alto custo associado a ela. A classificação pode usar muitas E / S de disco e pode ser executada por um longo tempo.
2. Na pior das hipóteses, o tempdb pode ficar sem espaço. Na melhor das hipóteses, o tempdb pode ocupar uma grande quantidade de espaço em disco que nunca será recuperada sem um comando de redução manual.

O que você precisa é uma maneira de selecionar linhas aleatoriamente que não usarão o tempdb e não ficarão muito mais lentas à medida que a tabela aumentar. Aqui está uma nova idéia de como fazer isso:

SELECT * FROM Table1
  WHERE (ABS(CAST(
  (BINARY_CHECKSUM(*) *
  RAND()) as int)) % 100) < 10

A idéia básica por trás dessa consulta é que queremos gerar um número aleatório entre 0 e 99 para cada linha da tabela e escolher todas as linhas cujo número aleatório é menor que o valor da porcentagem especificada. Neste exemplo, queremos aproximadamente 10% das linhas selecionadas aleatoriamente; portanto, escolhemos todas as linhas cujo número aleatório é menor que 10.

Leia o artigo completo no MSDN .

Se você (ao contrário do OP) precisar de um número específico de registros (o que dificulta a abordagem CHECKSUM) e desejar uma amostra mais aleatória do que a TABLESAMPLE fornece por si só, e também desejar uma velocidade melhor que a CHECKSUM, poderá se contentar com uma fusão da Métodos TABLESAMPLE e NEWID (), assim:

DECLARE @sampleCount int = 50
SET STATISTICS TIME ON

SELECT TOP (@sampleCount) * 
FROM [yourtable] TABLESAMPLE(10 PERCENT)
ORDER BY NEWID()

SET STATISTICS TIME OFF

No meu caso, esse é o compromisso mais direto entre aleatoriedade (não é realmente, eu sei) e velocidade. Varie a porcentagem (ou linhas) de TABLESAMPLE conforme apropriado - quanto maior a porcentagem, mais aleatória a amostra, mas espere uma queda linear na velocidade. (Observe que TABLESAMPLE não aceitará uma variável)

Apenas ordene a tabela por um número aleatório e obtenha as primeiras 5.000 linhas usando TOP.

SELECT TOP 5000 * FROM [Table] ORDER BY newid();

ATUALIZAR

Apenas tentei e uma newid()ligação é suficiente - não há necessidade de todos os elencos e toda a matemática.

Essa é uma combinação da ideia inicial da semente e de uma soma de verificação, que parece fornecer resultados aleatórios corretamente sem o custo de NEWID ():

SELECT TOP [number] 
FROM table_name
ORDER BY RAND(CHECKSUM(*) * RAND())

No MySQL você pode fazer isso:

SELECT `PRIMARY_KEY`, rand() FROM table ORDER BY rand() LIMIT 5000;

Ainda não vi essa variação nas respostas. Eu tinha uma restrição adicional onde precisava, com base em uma semente inicial, para selecionar o mesmo conjunto de linhas a cada vez.

Para MS SQL:

Exemplo mínimo:

select top 10 percent *
from table_name
order by rand(checksum(*))

Tempo de execução normalizado: 1,00

Exemplo NewId ():

select top 10 percent *
from table_name
order by newid()

Tempo de execução normalizado: 1,02

NewId()é insignificantemente mais lento que rand(checksum(*)), portanto, você pode não querer usá-lo em grandes conjuntos de registros.

Seleção com semente inicial:

declare @seed int
set @seed = Year(getdate()) * month(getdate()) /* any other initial seed here */

select top 10 percent *
from table_name
order by rand(checksum(*) % @seed) /* any other math function here */

Se você precisar selecionar o mesmo conjunto dado uma semente, isso parece funcionar.

Tente o seguinte:

SELECT TOP 10 Field1, ..., FieldN
FROM Table1
ORDER BY NEWID()

Parece que newid () não pode ser usado na cláusula where, portanto, esta solução requer uma consulta interna:

SELECT *
FROM (
    SELECT *, ABS(CHECKSUM(NEWID())) AS Rnd
    FROM MyTable
) vw
WHERE Rnd % 100 < 10        --10%

Eu estava usando-o na subconsulta e ele me retornou as mesmas linhas na subconsulta

 SELECT  ID ,
            ( SELECT TOP 1
                        ImageURL
              FROM      SubTable 
              ORDER BY  NEWID()
            ) AS ImageURL,
            GETUTCDATE() ,
            1
    FROM    Mytable

então eu resolvi com a inclusão de variável de tabela pai em que

SELECT  ID ,
            ( SELECT TOP 1
                        ImageURL
              FROM      SubTable 
              Where Mytable.ID>0
              ORDER BY  NEWID()
            ) AS ImageURL,
            GETUTCDATE() ,
            1
    FROM    Mytable

Observe a condição where

A linguagem de processamento do servidor em uso (por exemplo, PHP, .net, etc) não é especificada, mas se for PHP, pegue o número necessário (ou todos os registros) e, em vez de fazer aleatoriamente a consulta, use a função aleatória do PHP. Não sei se o .net tem uma função equivalente, mas se o fizer, use-o se você estiver usando o .net

ORDER BY RAND () pode ter uma penalidade de desempenho, dependendo de quantos registros estão envolvidos.

Isso funciona para mim:

SELECT * FROM table_name
ORDER BY RANDOM()
LIMIT [number]