Como selecionar linhas aleatoriamente no SQL?

Estou usando o MSSQL Server 2005. No meu banco de dados, tenho uma tabela "customerNames" que possui duas colunas "Id" e "Name" e aprox. 1.000 resultados.

Estou criando uma funcionalidade em que preciso escolher 5 clientes aleatoriamente todas as vezes. Alguém pode me dizer como criar uma consulta que obterá 5 linhas aleatórias (ID e nome) toda vez que a consulta for executada?

SELECT TOP 5 Id, Name FROM customerNames
ORDER BY NEWID()

Dito isto, todos parecem vir a esta página para obter uma resposta mais geral à sua pergunta:

Selecionando uma linha aleatória no SQL

Selecione uma linha aleatória com o MySQL:

SELECT column FROM table
ORDER BY RAND()
LIMIT 1

Selecione uma linha aleatória com o PostgreSQL:

SELECT column FROM table
ORDER BY RANDOM()
LIMIT 1

Selecione uma linha aleatória com o Microsoft SQL Server:

SELECT TOP 1 column FROM table
ORDER BY NEWID()

Selecione uma linha aleatória com o IBM DB2

SELECT column, RAND() as IDX 
FROM table 
ORDER BY IDX FETCH FIRST 1 ROWS ONLY

Selecione um registro aleatório com o Oracle:

SELECT column FROM
( SELECT column FROM table
ORDER BY dbms_random.value )
WHERE rownum = 1

Selecione uma linha aleatória com sqlite:

SELECT column FROM table 
ORDER BY RANDOM() LIMIT 1

SELECT TOP 5 Id, Name FROM customerNames ORDER BY NEWID()

Caso alguém queira uma solução PostgreSQL:

select id, name
from customer
order by random()
limit 5;

Talvez este site seja útil.

Para aqueles que não querem clicar:

SELECT TOP 1 column FROM table
ORDER BY NEWID()

Há uma boa solução específica do Microsoft SQL Server 2005 aqui. Lida com o problema em que você está trabalhando com um grande conjunto de resultados (não é a pergunta que eu sei).

Selecionando linhas aleatoriamente em uma tabela grande http://msdn.microsoft.com/en-us/library/cc441928.aspx

Se você tem uma tabela com milhões de linhas e se preocupa com o desempenho, esta poderia ser uma resposta melhor:

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

https://msdn.microsoft.com/en-us/library/cc441928.aspx

Essa é uma pergunta antiga, mas tentar aplicar um novo campo (NEWID () ou ORDER BY rand ()) a uma tabela com um grande número de linhas seria proibitivamente caro. Se você tiver IDs incrementais únicos (e não tiver nenhum furo), será mais eficiente calcular o número de Xs de ID a ser selecionado em vez de aplicar um GUID ou semelhante a cada linha e, em seguida, obter o número de X superior de.

DECLARE @minValue int;
DECLARE @maxValue int;
SELECT @minValue = min(id), @maxValue = max(id) from [TABLE];

DECLARE @randomId1 int, @randomId2 int, @randomId3 int, @randomId4 int, @randomId5 int
SET @randomId1 = ((@maxValue + 1) - @minValue) * Rand() + @minValue
SET @randomId2 = ((@maxValue + 1) - @minValue) * Rand() + @minValue
SET @randomId3 = ((@maxValue + 1) - @minValue) * Rand() + @minValue
SET @randomId4 = ((@maxValue + 1) - @minValue) * Rand() + @minValue
SET @randomId5 = ((@maxValue + 1) - @minValue) * Rand() + @minValue

--select @maxValue as MaxValue, @minValue as MinValue
--  , @randomId1 as SelectedId1
--  , @randomId2 as SelectedId2
--  , @randomId3 as SelectedId3
--  , @randomId4 as SelectedId4
--  , @randomId5 as SelectedId5

select * from [TABLE] el
where el.id in (@randomId1, @randomId2, @randomId3, @randomId4, @randomId5)

Se você quisesse selecionar muito mais linhas, gostaria de preencher uma #tempTable com um ID e vários valores de rand () e, em seguida, usar cada valor de rand () para dimensionar para os valores min-max. Dessa forma, você não precisa definir todos os parâmetros @ randomId1 ... n. Incluí um exemplo abaixo usando um CTE para preencher a tabela inicial.

DECLARE @NumItems int = 100;

DECLARE @minValue int;
DECLARE @maxValue int;
SELECT @minValue = min(id), @maxValue = max(id) from [TABLE];
DECLARE @range int = @maxValue+1 - @minValue;

with cte (n) as (
   select 1 union all
   select n+1 from cte
   where n < @NumItems
)
select cast( @range * rand(cast(newid() as varbinary(100))) + @minValue as int) tp
into #Nt
from cte;

select * from #Nt ntt
inner join [TABLE] i on i.id = ntt.tp;

drop table #Nt;

SELECT * FROM TABLENAME ORDER BY random() LIMIT 5; 

Descobri que isso funciona melhor para big data.

SELECT TOP 1 Column_Name FROM dbo.Table TABLESAMPLE(1 PERCENT);

TABLESAMPLE(n ROWS) or TABLESAMPLE(n PERCENT)é aleatório, mas é necessário adicionar o TOP npara obter o tamanho de amostra correto.

O uso NEWID()é muito lento em tabelas grandes.

Como expliquei neste artigo , para embaralhar o conjunto de resultados SQL, você precisa usar uma chamada de função específica do banco de dados.

Observe que a classificação de um grande conjunto de resultados usando uma função RANDOM pode ser muito lenta, portanto, faça isso em pequenos conjuntos de resultados.

Se você precisar embaralhar um grande conjunto de resultados e limitá-lo posteriormente, é melhor usar algo como o OracleSAMPLE(N) ou TABLESAMPLEno SQL Server ou no PostgreSQL, em vez de uma função aleatória na cláusula ORDER BY.

Portanto, supondo que tenhamos a seguinte tabela de banco de dados:

E as seguintes linhas na songtabela:

| id | artist                          | title                              |
|----|---------------------------------|------------------------------------|
| 1  | Miyagi & Эндшпиль ft. Рем Дигга | I Got Love                         |
| 2  | HAIM                            | Don't Save Me (Cyril Hahn Remix)   |
| 3  | 2Pac ft. DMX                    | Rise Of A Champion (GalilHD Remix) |
| 4  | Ed Sheeran & Passenger          | No Diggity (Kygo Remix)            |
| 5  | JP Cooper ft. Mali-Koa          | All This Love                      |

Oráculo

No Oracle, você precisa usar a DBMS_RANDOM.VALUEfunção, conforme ilustrado no seguinte exemplo:

SELECT
    artist||' - '||title AS song
FROM song
ORDER BY DBMS_RANDOM.VALUE

Ao executar a consulta SQL acima mencionada no Oracle, obteremos o seguinte conjunto de resultados:

| song                                              |
|---------------------------------------------------|
| JP Cooper ft. Mali-Koa - All This Love            |
| 2Pac ft. DMX - Rise Of A Champion (GalilHD Remix) |
| HAIM - Don't Save Me (Cyril Hahn Remix)           |
| Ed Sheeran & Passenger - No Diggity (Kygo Remix)  |
| Miyagi & Эндшпиль ft. Рем Дигга - I Got Love      |

Observe que as músicas estão sendo listadas aleatoriamente, graças à DBMS_RANDOM.VALUEchamada de função usada pela cláusula ORDER BY.

servidor SQL

No SQL Server, você precisa usar a NEWIDfunção, conforme ilustrado no seguinte exemplo:

SELECT
    CONCAT(CONCAT(artist, ' - '), title) AS song
FROM song
ORDER BY NEWID()

Ao executar a consulta SQL acima mencionada no SQL Server, obteremos o seguinte conjunto de resultados:

| song                                              |
|---------------------------------------------------|
| Miyagi & Эндшпиль ft. Рем Дигга - I Got Love      |
| JP Cooper ft. Mali-Koa - All This Love            |
| HAIM - Don't Save Me (Cyril Hahn Remix)           |
| Ed Sheeran & Passenger - No Diggity (Kygo Remix)  |
| 2Pac ft. DMX - Rise Of A Champion (GalilHD Remix) |

Observe que as músicas estão sendo listadas aleatoriamente, graças à NEWIDchamada de função usada pela cláusula ORDER BY.

PostgreSQL

No PostgreSQL, você precisa usar a randomfunção, conforme ilustrado no seguinte exemplo:

SELECT
    artist||' - '||title AS song
FROM song
ORDER BY random()

Ao executar a consulta SQL acima mencionada no PostgreSQL, obteremos o seguinte conjunto de resultados:

| song                                              |
|---------------------------------------------------|
| 2Pac ft. DMX - Rise Of A Champion (GalilHD Remix) |
| JP Cooper ft. Mali-Koa - All This Love            |
| Ed Sheeran & Passenger - No Diggity (Kygo Remix)  |
| HAIM - Don't Save Me (Cyril Hahn Remix)           |
| Miyagi & Эндшпиль ft. Рем Дигга - I Got Love      |

Observe que as músicas estão sendo listadas aleatoriamente, graças à randomchamada de função usada pela cláusula ORDER BY.

MySQL

No MySQL, você precisa usar a RANDfunção, conforme ilustrado no exemplo a seguir:

SELECT
  CONCAT(CONCAT(artist, ' - '), title) AS song
FROM song
ORDER BY RAND()

Ao executar a consulta SQL acima mencionada no MySQL, obteremos o seguinte conjunto de resultados:

| song                                              |
|---------------------------------------------------|
| HAIM - Don't Save Me (Cyril Hahn Remix)           |
| Ed Sheeran & Passenger - No Diggity (Kygo Remix)  |
| Miyagi & Эндшпиль ft. Рем Дигга - I Got Love      |
| 2Pac ft. DMX - Rise Of A Champion (GalilHD Remix) |
| JP Cooper ft. Mali-Koa - All This Love            |

Observe que as músicas estão sendo listadas aleatoriamente, graças à RANDchamada de função usada pela cláusula ORDER BY.

Se você estiver usando uma tabela grande e quiser acessar 10% dos dados, execute o seguinte comando: SELECT TOP 10 PERCENT * FROM Table1 ORDER BY NEWID();