Come prendo un campione casuale semplice ed efficiente in SQL? Il database in questione esegue MySQL; la mia tabella è di almeno 200.000 righe e voglio un semplice campione casuale di circa 10.000.

La risposta "ovvia" è:

SELECT * FROM table ORDER BY RAND() LIMIT 10000

Per le tabelle di grandi dimensioni, è troppo lento: richiede RAND()ogni riga (che la mette già a O (n)) e le ordina, rendendola O (n lg n) nella migliore delle ipotesi. C'è un modo per farlo più velocemente di O (n)?

Nota : come sottolinea Andrew Mao nei commenti, se stai usando questo approccio su SQL Server, dovresti usare la funzione T-SQL NEWID(), perché RAND () può restituire lo stesso valore per tutte le righe .

MODIFICA: 5 ANNI DOPO

Mi sono imbattuto di nuovo in questo problema con una tabella più grande e ho finito per utilizzare una versione della soluzione di @ ignorant, con due modifiche:

• Campiona le righe fino a 2-5 volte la dimensione del campione desiderata, a poco prezzo ORDER BY RAND()
• Salva il risultato di RAND()in una colonna indicizzata a ogni inserimento / aggiornamento. (Se il tuo set di dati non è molto ricco di aggiornamenti, potresti dover trovare un altro modo per mantenere aggiornata questa colonna.)

Per prendere un campione di 1000 elementi di una tabella, conto le righe e campionamento il risultato fino a, in media, 10.000 righe con la colonna frozen_rand:

SELECT COUNT(*) FROM table; -- Use this to determine rand_low and rand_high

  SELECT *
    FROM table
   WHERE frozen_rand BETWEEN %(rand_low)s AND %(rand_high)s
ORDER BY RAND() LIMIT 1000

(La mia implementazione effettiva richiede più lavoro per assicurarmi di non sottocampionare e per racchiudere manualmente rand_high, ma l'idea di base è "tagliare a caso il tuo N a poche migliaia")

Sebbene ciò comporti alcuni sacrifici, mi consente di campionare il database utilizzando una scansione dell'indice, finché non è abbastanza piccolo da poterlo ORDER BY RAND()nuovamente.

C'è una discussione molto interessante su questo tipo di problema qui: http://www.titov.net/2005/09/21/do-not-use-order-by-rand-or-how-to-get-random-rows-from-table/

Penso, senza alcuna ipotesi sulla tabella, che la tua soluzione O (n lg n) sia la migliore. Sebbene in realtà con un buon ottimizzatore o una tecnica leggermente diversa la query che elenchi potrebbe essere un po 'migliore, O (m * n) dove m è il numero di righe casuali desiderate, poiché non è necessario ordinare l'intero array di grandi dimensioni , potrebbe cercare solo le m volte più piccole. Ma per il tipo di numeri che hai postato, m è comunque più grande di lg n.

Tre ipotesi che potremmo provare:

1. c'è una chiave primaria univoca, indicizzata, nella tabella

2. il numero di righe casuali che si desidera selezionare (m) è molto inferiore al numero di righe nella tabella (n)

3. la chiave primaria univoca è un numero intero compreso tra 1 an senza spazi

Con solo le ipotesi 1 e 2, penso che questo possa essere fatto in O (n), anche se dovrai scrivere un intero indice sulla tabella per far corrispondere l'ipotesi 3, quindi non è necessariamente un veloce O (n). Se possiamo INOLTRE presumere qualcos'altro di carino sulla tabella, possiamo eseguire il compito in O (m log m). L'assunzione 3 sarebbe una proprietà aggiuntiva facile e piacevole con cui lavorare. Con un bel generatore di numeri casuali che non garantisse duplicati durante la generazione di m numeri di fila, sarebbe possibile una soluzione O (m).

Date le tre ipotesi, l'idea di base è generare m numeri casuali univoci compresi tra 1 e n, quindi selezionare le righe con quelle chiavi dalla tabella. Non ho mysql o altro davanti a me in questo momento, quindi in un po 'di pseudocodice questo sarebbe qualcosa del tipo:

create table RandomKeys (RandomKey int)
create table RandomKeysAttempt (RandomKey int)

-- generate m random keys between 1 and n
for i = 1 to m
  insert RandomKeysAttempt select rand()*n + 1

-- eliminate duplicates
insert RandomKeys select distinct RandomKey from RandomKeysAttempt

-- as long as we don't have enough, keep generating new keys,
-- with luck (and m much less than n), this won't be necessary
while count(RandomKeys) < m
  NextAttempt = rand()*n + 1
  if not exists (select * from RandomKeys where RandomKey = NextAttempt)
    insert RandomKeys select NextAttempt

-- get our random rows
select *
from RandomKeys r
join table t ON r.RandomKey = t.UniqueKey

Se fossi veramente preoccupato per l'efficienza, potresti prendere in considerazione la possibilità di generare la chiave casuale in una sorta di linguaggio procedurale e inserire i risultati nel database, poiché quasi qualsiasi cosa diversa da SQL sarebbe probabilmente migliore nel tipo di loop e generazione di numeri casuali richiesti .

Penso che la soluzione più veloce sia

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

Ecco perché penso che questo dovrebbe fare il lavoro.

• Creerà un numero casuale per ogni riga. Il numero è compreso tra 0 e 1
• Valuta se visualizzare quella riga se il numero generato è compreso tra 0 e 0,3 (30%).

Ciò presuppone che rand () generi numeri in una distribuzione uniforme. È il modo più rapido per farlo.

Ho visto che qualcuno aveva consigliato quella soluzione e sono stati abbattuti senza prove .. ecco cosa direi a questo -

• Questo è O (n) ma non è richiesto alcun ordinamento quindi è più veloce di O (n lg n)

• mysql è molto in grado di generare numeri casuali per ogni riga. Prova questo -

  seleziona rand () dal limite di INFORMATION_SCHEMA.TABLES 10;

Poiché il database in questione è mySQL, questa è la soluzione giusta.

Apparentemente in alcune versioni di SQL c'è un TABLESAMPLEcomando, ma non è in tutte le implementazioni SQL (in particolare, Redshift).

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

Basta usare

WHERE RAND() < 0.1 

per ottenere il 10% dei record o

WHERE RAND() < 0.01 

per ottenere l'1% dei record, ecc.

Più veloce di ORDER BY RAND ()

Ho testato questo metodo per essere molto più veloce di ORDER BY RAND(), quindi funziona in O (n) tempo e lo fa in modo straordinariamente veloce.

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

Versione non MSSQL : non l'ho testata

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

Versione MSSQL:

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

Questo selezionerà ~ 1% dei record. Quindi, se è necessario selezionare il numero esatto di percentuali o record, stima la percentuale con un certo margine di sicurezza, quindi estrai casualmente i record in eccesso dal set risultante, utilizzando il più costosoORDER BY RAND() metodo .

Ancora più veloce

Sono stato in grado di migliorare ulteriormente questo metodo perché avevo un noto intervallo di valori delle colonne indicizzate.

Ad esempio, se si dispone di una colonna indicizzata con interi distribuiti uniformemente [0..max], è possibile utilizzarla per selezionare N piccoli intervalli in modo casuale. Eseguire questa operazione dinamicamente nel programma per ottenere un set diverso per ogni esecuzione di query. Questa selezione di sottoinsieme sarà O (N) , che può essere inferiore di molti ordini di grandezza rispetto al set di dati completo.

Nel mio test ho ridotto il tempo necessario per ottenere 20 record di campioni (su 20 mil) da 3 minuti utilizzando ORDER BY RAND () fino a 0,0 secondi !

Voglio sottolineare che tutte queste soluzioni sembrano campionare senza sostituzione. La selezione delle prime K righe da un ordinamento casuale o l'unione a una tabella che contiene chiavi univoche in ordine casuale produrrà un campione casuale generato senza sostituzione.

Se vuoi che il tuo campione sia indipendente, dovrai campionare con la sostituzione. Vedere la domanda 25451034 per un esempio di come eseguire questa operazione utilizzando un JOIN in un modo simile alla soluzione di user12861. La soluzione è scritta per T-SQL, ma il concetto funziona in qualsiasi database SQL.

Partendo dall'osservazione che possiamo recuperare gli id ​​di una tabella (es. Count 5) in base a un set:

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

possiamo arrivare al risultato che se potessimo generare la stringa "(4, 1, 2, 5, 3)", allora avremmo un modo più efficiente diRAND() .

Ad esempio, in 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 gli ID presentano spazi vuoti, l'arraylist iniziale indicesè il risultato di una query SQL sugli ID.

Se hai bisogno di mrighe esatte , realisticamente genererai il tuo sottoinsieme di ID al di fuori di SQL. La maggior parte dei metodi richiede a un certo punto di selezionare la voce "n-esima" e le tabelle SQL non sono affatto array. Anche l'ipotesi che le chiavi siano consecutive per unire solo int casuali tra 1 e il conteggio è difficile da soddisfare: MySQL ad esempio non lo supporta in modo nativo e le condizioni di blocco sono ... complicate .

Ecco una soluzione O(max(n, m lg n))-time, O(n)-space assumendo solo semplici tasti BTREE:

1. Recupera tutti i valori della colonna chiave della tabella dati in qualsiasi ordine in un array nel tuo linguaggio di scripting preferito in O(n)
2. Eseguire un riordino Fisher-Yates , fermandosi dopo mgli swap, ed estrarre il sottoarray [0:m-1]inϴ(m)
3. "Unisci" il sottoarray con il set di dati originale (ad esempio SELECT ... WHERE id IN (<subarray>)) inO(m lg n)

Qualsiasi metodo che genera il sottoinsieme casuale al di fuori di SQL deve avere almeno questa complessità. Il join non può essere più veloce che O(m lg n)con BTREE (quindi le O(m)affermazioni sono fantastiche per la maggior parte dei motori) e lo shuffle è delimitato sotto ne m lg nnon influisce sul comportamento asintotico.

Nello pseudocodice pitonico:

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

Seleziona 3000 record casuali in Netezza:

WITH IDS AS (
     SELECT ID
     FROM MYTABLE;
)

SELECT ID FROM IDS ORDER BY mt_random() LIMIT 3000

Provare

SELECT TOP 10000 * FROM table ORDER BY NEWID()

Questo darebbe i risultati desiderati, senza essere troppo complicato?

In alcuni dialetti come Microsoft SQL Server, PostgreSQL e Oracle (ma non MySQL o SQLite), puoi fare qualcosa come

select distinct top 10000 customer_id from nielsen.dbo.customer TABLESAMPLE (20000 rows) REPEATABLE (123);

La ragione per non fare a (10000 rows)meno di topè che la TABLESAMPLElogica ti dà un numero estremamente inesatto di righe (come a volte il 75%, a volte l'1,25% di volte), quindi vuoi sovracampionare e selezionare il numero esatto che desideri. Il REPEATABLE (123)è per fornire un seme casuale.

Forse potresti farlo

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