Seleziona n righe casuali dalla tabella di SQL Server

Ho una tabella di SQL Server con circa 50.000 righe. Voglio selezionare casualmente circa 5.000 di quelle righe. Ho pensato a un modo complicato, creando una tabella temporanea con una colonna "numero casuale", copiando la mia tabella in quella, eseguendo il ciclo attraverso la tabella temporanea e aggiornando ogni riga con RAND(), quindi selezionando da quella tabella in cui la colonna di numeri casuali < 0.1. Sto cercando un modo più semplice per farlo, in una singola dichiarazione, se possibile.

Questo articolo suggerisce di utilizzare la NEWID()funzione. Sembra promettente, ma non riesco a vedere come potrei selezionare in modo affidabile una certa percentuale di righe.

Qualcuno l'ha mai fatto prima? Qualche idea?

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

In risposta al commento "puro cestino" riguardante le tabelle di grandi dimensioni: è possibile farlo in questo modo per migliorare le prestazioni.

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

Il costo di questo sarà la scansione chiave dei valori più il costo di join, che su una tabella di grandi dimensioni con una piccola percentuale di selezione dovrebbe essere ragionevole.

A seconda delle tue esigenze, TABLESAMPLEotterrai prestazioni altrettanto casuali e migliori. questo è disponibile su MS SQL Server 2005 e versioni successive.

TABLESAMPLE restituirà i dati da pagine casuali invece di righe casuali e quindi deos non recupera nemmeno i dati che non restituiranno.

Ho provato su un tavolo molto grande

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

ci sono voluti più di 20 minuti.

select * from [tablename] tablesample(1 percent)

ci sono voluti 2 minuti.

Le prestazioni miglioreranno anche su campioni più piccoli, TABLESAMPLEmentre non lo saranno newid().

Tieni presente che questo non è casuale come il newid()metodo, ma ti darà un campionamento decente.

Vedi la pagina MSDN .

newid () / order by funzionerà, ma sarà molto costoso per grandi serie di risultati perché deve generare un ID per ogni riga e quindi ordinarle.

TABLESAMPLE () è buono dal punto di vista delle prestazioni, ma otterrai un raggruppamento dei risultati (verranno restituite tutte le righe di una pagina).

Per un campione casuale vero con prestazioni migliori, il modo migliore è filtrare le righe in modo casuale. Ho trovato il seguente esempio di codice nell'articolo della documentazione in linea di SQL Server Limitazione dei set di risultati tramite TABLESAMPLE :

Se desideri davvero un campione casuale di singole righe, modifica la query per filtrare le righe in modo casuale, anziché utilizzare TABLESAMPLE. Ad esempio, la query seguente utilizza la funzione NEWID per restituire circa l'uno percento delle righe della tabella Sales.SalesOrderDetail:

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

La colonna SalesOrderID è inclusa nell'espressione CHECKSUM in modo che NEWID () valuti una volta per riga per ottenere il campionamento su base per riga. L'espressione CAST (CHECKSUM (NEWID (), SalesOrderID) e 0x7fffffff AS float / CAST (0x7fffffff AS int) restituisce un valore float casuale compreso tra 0 e 1.

Quando eseguito contro una tabella con 1.000.000 di righe, ecco i miei risultati:

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 riesci a cavartela usando TABLESAMPLE, ti darà le migliori prestazioni. Altrimenti usa il metodo newid () / filter. newid () / ordina per dovrebbe essere l'ultima risorsa se si dispone di un set di risultati di grandi dimensioni.

Selezione casuale delle righe da una tabella di grandi dimensioni su MSDN ha una soluzione semplice e ben articolata che risolve i problemi di prestazioni su larga scala.

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

Questo collegamento presenta un interessante confronto tra Orderby (NEWID ()) e altri metodi per le tabelle con 1, 7 e 13 milioni di righe.

Spesso, quando vengono poste domande su come selezionare righe casuali nei gruppi di discussione, viene proposta la query NEWID; è semplice e funziona molto bene per i tavolini.

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

Tuttavia, la query NEWID ha un grosso svantaggio quando la si utilizza per tabelle di grandi dimensioni. La clausola ORDER BY fa sì che tutte le righe della tabella vengano copiate nel database tempdb, dove vengono ordinate. Ciò causa due problemi:

1. L'operazione di smistamento di solito comporta un costo elevato. L'ordinamento può utilizzare un sacco di I / O su disco e può funzionare a lungo.
2. Nel peggiore dei casi, tempdb può esaurire lo spazio. Nel migliore dei casi, tempdb può occupare una grande quantità di spazio su disco che non sarà mai recuperato senza un comando di riduzione manuale.

Ciò di cui hai bisogno è un modo per selezionare casualmente le righe che non utilizzeranno tempdb e non diventeranno molto più lente man mano che la tabella diventa più grande. Ecco una nuova idea su come farlo:

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

L'idea di base alla base di questa query è che vogliamo generare un numero casuale compreso tra 0 e 99 per ogni riga della tabella e quindi scegliere tutte quelle righe il cui numero casuale sia inferiore al valore della percentuale specificata. In questo esempio, vogliamo circa il 10 percento delle righe selezionate casualmente; pertanto, scegliamo tutte le righe il cui numero casuale è inferiore a 10.

Si prega di leggere l'articolo completo in MSDN .

Se (a differenza del PO) hai bisogno di un numero specifico di record (il che rende difficile l'approccio CHECKSUM) e desideri un campione più casuale di quello che TABLESAMPLE fornisce da solo, e desideri anche una velocità migliore di CHECKSUM, puoi accontentarti di una fusione del Metodi TABLESAMPLE e NEWID (), come questo:

DECLARE @sampleCount int = 50
SET STATISTICS TIME ON

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

SET STATISTICS TIME OFF

Nel mio caso questo è il compromesso più diretto tra casualità (non è davvero, lo so) e velocità. Varia la percentuale (o le righe) di TABLESAMPLE nel modo appropriato: più alta è la percentuale, più casuale è il campione, ma aspettati un calo lineare della velocità. (Nota che TABLESAMPLE non accetterà una variabile)

Basta ordinare la tabella con un numero casuale e ottenere le prime 5.000 righe usando TOP.

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

AGGIORNARE

Ho appena provato e una newid()chiamata è sufficiente - non è necessario per tutti i cast e tutta la matematica.

Questa è una combinazione dell'idea iniziale iniziale e di una somma di controllo, che mi sembra dare risultati casuali senza il costo di NEWID ():

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

In MySQL puoi farlo:

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

Non ho ancora visto questa variazione nelle risposte. Avevo un vincolo aggiuntivo dove avevo bisogno, dato un seme iniziale, di selezionare ogni volta lo stesso insieme di righe.

Per MS SQL:

Esempio minimo:

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

Tempo di esecuzione normalizzato: 1,00

Esempio NewId ():

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

Tempo di esecuzione normalizzato: 1,02

NewId()è insignificantemente più lento di rand(checksum(*)), quindi potresti non volerlo usare contro grandi set di record.

Selezione con seme iniziale:

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 devi selezionare lo stesso set dato un seme, questo sembra funzionare.

Prova questo:

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

Sembra che newid () non possa essere usato nella clausola where, quindi questa soluzione richiede una query interna:

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

Lo stavo usando in subquery e mi ha restituito le stesse righe in subquery

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

poi ho risolto includendo la variabile della tabella padre in where

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

Nota la condizione dove

Il linguaggio di elaborazione lato server in uso (ad esempio PHP, .net, ecc.) Non è specificato, ma se è PHP, prendi il numero richiesto (o tutti i record) e invece di randomizzare nella query usa la funzione shuffle di PHP. Non so se .net ha una funzione equivalente, ma se lo fa allora usalo se stai usando .net

ORDER BY RAND () può avere una penalità piuttosto elevata, a seconda del numero di record coinvolti.

Questo funziona per me:

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