एक Sql डेटाबेस से सरल यादृच्छिक नमूने

Question 1

मैं SQL में एक कुशल सरल यादृच्छिक नमूना कैसे ले सकता हूँ? प्रश्न में डेटाबेस MySQL चला रहा है; मेरी तालिका कम से कम 200,000 पंक्तियाँ है, और मुझे लगभग 10,000 का एक सरल यादृच्छिक नमूना चाहिए।

"स्पष्ट" उत्तर है:

SELECT * FROM table ORDER BY RAND() LIMIT 10000

बड़ी तालिकाओं के लिए, यह बहुत धीमी है: यह RAND()हर पंक्ति (जो पहले से ही इसे ओ (एन) पर रखती है) के लिए कॉल करती है , और उन्हें छांटती है, जिससे यह ओ (एन एलजी एन) सबसे अच्छा होता है। क्या O (n) की तुलना में इसे तेज़ करने का कोई तरीका है?

नोट : जैसा कि एंड्रयू माओ टिप्पणियों में बताते हैं, यदि आप SQL सर्वर पर इस दृष्टिकोण का उपयोग कर रहे हैं, तो आपको T-SQL फ़ंक्शन का उपयोग करना चाहिए NEWID(), क्योंकि RAND () सभी पंक्तियों के लिए समान मान वापस कर सकता है ।

संपादित करें: 5 साल की उम्र

मैं एक बड़ी तालिका के साथ फिर से इस समस्या में भाग गया, और दो अज्ञानी लोगों के साथ @ अज्ञानी समाधान के एक संस्करण का उपयोग करके समाप्त हो गया:

सस्ते के लिए पंक्तियों को 2-5x मेरे वांछित नमूने के आकार का नमूना दें ORDER BY RAND()
RAND()प्रत्येक इन्सर्ट / अपडेट पर एक अनुक्रमित कॉलम के परिणाम को सहेजें । (यदि आपका डेटा सेट बहुत अपडेट-भारी नहीं है, तो आपको इस कॉलम को नया बनाए रखने के लिए दूसरा तरीका खोजने की आवश्यकता हो सकती है।)

किसी तालिका का 1000-आइटम नमूना लेने के लिए, मैं पंक्तियों की गणना करता हूं और परिणाम को नीचे की ओर ले जाता हूं, औसतन, 10,000 पंक्तियों को जमे हुए_और कॉलम के साथ:

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

(मेरे वास्तविक कार्यान्वयन में यह सुनिश्चित करने के लिए अधिक काम शामिल है कि मैं अंडरस्लैम नहीं करता हूं, और मैन्युअल रूप से rand_high को चारों ओर लपेटने के लिए, लेकिन मूल विचार "बेतरतीब ढंग से अपने एन को कुछ हज़ार में कटौती करना है।")

हालांकि यह कुछ बलिदान करता है, यह मुझे एक सूचकांक स्कैन का उपयोग करके डेटाबेस को नमूना करने की अनुमति देता है, जब तक कि यह ORDER BY RAND()फिर से छोटा न हो ।

Question 2

इस प्रकार के मुद्दे की बहुत दिलचस्प चर्चा यहाँ है: http://www.titov.net/2005/09/21/do-not-use-order-by-rand-or-how-to-get-random-rows-from-table/

मुझे लगता है कि आपके O (n lg n) समाधान तालिका के बारे में बिल्कुल कोई धारणा नहीं है। हालांकि वास्तव में एक अच्छे ऑप्टिमाइज़र या थोड़ी अलग तकनीक से आपके द्वारा सूचीबद्ध की जाने वाली क्वेरी थोड़ी बेहतर हो सकती है, O (m * n) जहां m वांछित पंक्तियों की संख्या है, क्योंकि इसके लिए पूरे बड़े सरणी को क्रमबद्ध नहीं करना पड़ेगा , यह केवल सबसे छोटे समय के लिए खोज कर सकता है। लेकिन आपके द्वारा पोस्ट किए जाने वाले नंबरों के लिए, मी वैसे भी lg n से बड़ा है।

तीन अनुमान जो हम आजमा सकते हैं:

तालिका में एक अद्वितीय, अनुक्रमित, प्राथमिक कुंजी है
तालिका (n) में पंक्तियों की संख्या की तुलना में आपके द्वारा चुनी जाने वाली यादृच्छिक पंक्तियों की संख्या (m) बहुत कम है
अद्वितीय प्राथमिक कुंजी एक पूर्णांक है जो बिना अंतराल के 1 से n तक होती है

केवल मान्यताओं 1 और 2 के साथ, मुझे लगता है कि यह O (n) में किया जा सकता है, हालांकि आपको अनुमान 3 से मिलान करने के लिए तालिका को एक संपूर्ण सूचकांक लिखने की आवश्यकता होगी, इसलिए यह संक्षेप में एक तेज O (n) नहीं है। यदि हम ADDITIONALLY को तालिका के बारे में कुछ और अच्छा लगा सकते हैं, तो हम कार्य को O (m log m) में कर सकते हैं। मान लिया जाए कि 3 काम करने के लिए एक आसान अच्छी अतिरिक्त संपत्ति होगी। एक अच्छा यादृच्छिक संख्या जनरेटर के साथ, जो किसी पंक्ति में एम संख्या उत्पन्न करते समय कोई डुप्लिकेट की गारंटी नहीं देता है, एक ओ (एम) समाधान संभव होगा।

तीन मान्यताओं को देखते हुए, मूल विचार 1 और n के बीच मी अद्वितीय रैंडम संख्या उत्पन्न करना है, और फिर तालिका से उन कुंजियों के साथ पंक्तियों का चयन करना है। अभी मेरे सामने mysql या कुछ भी नहीं है, इसलिए थोड़े से pseudocode में यह कुछ इस तरह दिखाई देगा:


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

यदि आप वास्तव में दक्षता के बारे में चिंतित थे, तो आप किसी तरह की प्रक्रियात्मक भाषा में यादृच्छिक कुंजी पीढ़ी करने और डेटाबेस में परिणाम सम्मिलित करने पर विचार कर सकते हैं, क्योंकि SQL के अलावा लगभग कुछ भी संभवतः लूपिंग और यादृच्छिक संख्या पीढ़ी के प्रकार में बेहतर होगा। ।

Question 3

मुझे लगता है कि सबसे तेज समाधान है

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

यहाँ मुझे लगता है कि यह काम करना चाहिए।

यह प्रत्येक पंक्ति के लिए एक यादृच्छिक संख्या बनाएगा। संख्या 0 और 1 के बीच है
यह मूल्यांकन करता है कि क्या उस पंक्ति को प्रदर्शित करना है यदि उत्पन्न संख्या 0 और .3 (30%) के बीच है।

यह मानता है कि रैंड () एक समान वितरण में संख्या उत्पन्न कर रहा है। यह ऐसा करने का सबसे तेज तरीका है।

मैंने देखा कि किसी ने उस समाधान की सिफारिश की थी और उन्हें बिना सबूत के गोली मार दी गई थी .. यहाँ मैं उस पर क्या कहूंगा -

यह O (n) है लेकिन किसी प्रकार की छंटाई की आवश्यकता नहीं है इसलिए यह O (n lg n) से तेज है
mysql प्रत्येक पंक्ति के लिए यादृच्छिक संख्या उत्पन्न करने में बहुत सक्षम है। इसे इस्तेमाल करे -

INFORMATION_SCHEMA.TABLES सीमा 10 से रैंड () चुनें;

चूंकि प्रश्न में डेटाबेस mySQL है, इसलिए यह सही समाधान है।

Question 4

एसक्यूएल के कुछ संस्करणों में स्पष्ट रूप से एक TABLESAMPLEकमांड है, लेकिन यह सभी एसक्यूएल कार्यान्वयन (विशेषकर, रेडशिफ्ट) में नहीं है।

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

Question 5

महज प्रयोग करें

WHERE RAND() < 0.1

अभिलेखों का 10% प्राप्त करने के लिए या

WHERE RAND() < 0.01

1% रिकॉर्ड प्राप्त करने के लिए, आदि।

Question 6

रैंड द्वारा तेजी से आगे ()

मैंने इस पद्धति का परीक्षण करने की तुलना में बहुत तेज है ORDER BY RAND(), इसलिए यह ओ (एन) समय में चलता है , और इतनी प्रभावशाली तेजी से करता है।

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

गैर-MSSQL संस्करण - मैंने इसका परीक्षण नहीं किया

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

MSSQL संस्करण:

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

यह ~ 1% रिकॉर्ड का चयन करेगा। इसलिए यदि आपको चयनित होने के लिए सटीक # प्रतिशत या रिकॉर्ड की आवश्यकता है, तो कुछ सुरक्षा मार्जिन के साथ अपने प्रतिशत का अनुमान लगाएं, फिर परिणामी सेट से अतिरिक्त रिकॉर्ड को अधिक महंगी ORDER BY RAND()विधि का उपयोग करके बेतरतीब ढंग से प्लक करें ।

और भी तेज

मैं आगे भी इस पद्धति में सुधार करने में सक्षम था क्योंकि मेरे पास एक प्रसिद्ध अनुक्रमित स्तंभ मान सीमा थी।

उदाहरण के लिए, यदि आपके पास समान रूप से वितरित पूर्णांक [0..max] के साथ एक अनुक्रमित स्तंभ है, तो आप इसका उपयोग बेतरतीब ढंग से N छोटे अंतराल का चयन करने के लिए कर सकते हैं। प्रत्येक क्वेरी रन के लिए एक अलग सेट प्राप्त करने के लिए अपने प्रोग्राम में इसे गतिशील रूप से करें। यह सबसेट चयन O (N) होगा , जो आपके पूर्ण डेटा सेट की तुलना में छोटे परिमाण के कई ऑर्डर कर सकता है।

अपने परीक्षण में मैंने 0.0 सेकंड तक ORDER BY RAND () का उपयोग करके 3 मिनट से 20 (आउट 20 मील) नमूना रिकॉर्ड प्राप्त करने के लिए आवश्यक समय कम कर दिया !

Question 7

मैं यह बताना चाहता हूं कि इन सभी समाधानों को प्रतिस्थापन के बिना नमूना दिखाई देता है। यादृच्छिक क्रम से शीर्ष K पंक्तियों का चयन करना या यादृच्छिक क्रम में अद्वितीय कुंजियों वाली तालिका में शामिल होने से प्रतिस्थापन के बिना उत्पन्न एक यादृच्छिक नमूना प्राप्त होगा।

यदि आप चाहते हैं कि आपका नमूना स्वतंत्र हो, तो आपको प्रतिस्थापन के साथ नमूना लेना होगा। उपयोगकर्ता के 12861 के समाधान के समान तरीके से जॉयइन का उपयोग करने के तरीके के एक उदाहरण के लिए प्रश्न 25451034 देखें । समाधान T-SQL के लिए लिखा गया है, लेकिन अवधारणा किसी भी SQL db में काम करती है।

Question 8

अवलोकन के साथ शुरू करना जो हम एक सेट के आधार पर एक तालिका के आईडी को पुनः प्राप्त कर सकते हैं (जैसे। गिनती 5):

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

हम इस परिणाम पर आ सकते हैं कि यदि हम स्ट्रिंग उत्पन्न कर सकते हैं "(4, 1, 2, 5, 3)", तो हमारे पास इससे अधिक कुशल तरीका होगा RAND()।

उदाहरण के लिए, जावा में:

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(']', ')');

यदि आईडी में अंतराल है, तो प्रारंभिक सरणी सूची indicesआईडी पर sql क्वेरी का परिणाम है।

Question 9

यदि आपको बिल्कुल mपंक्तियों की आवश्यकता है , तो वास्तविक रूप से आप SQL के बाहर आईडी का अपना सबसेट उत्पन्न करेंगे। अधिकांश तरीकों को "एनटीटी" प्रविष्टि का चयन करने के लिए कुछ बिंदु पर आवश्यकता होती है, और SQL टेबल वास्तव में सरणियां नहीं हैं। यह धारणा कि कुंजियाँ लगातार बनी हुई हैं, केवल 1 और गिनती के बीच यादृच्छिक आवृत्तियों को जोड़ने के लिए भी संतुष्ट करना मुश्किल है - उदाहरण के लिए MySQL मूल रूप से इसका समर्थन नहीं करता है, और लॉक की स्थिति ... मुश्किल है ।

यहाँ O(max(n, m lg n))समय-समय पर, O(n)केवल सादा बीटीआरई कुंजियों के आधार पर समाधान उपलब्ध है:

अपनी पसंदीदा स्क्रिप्टिंग भाषा में किसी भी क्रम में किसी भी क्रम में डेटा तालिका के प्रमुख स्तंभ के सभी मान प्राप्त करें O(n)
फिशर-येट्स फेरबदल प्रदर्शन करें , mस्वैप के बाद रोकना , और सबरे को [0:m-1]अंदर निकालनाϴ(m)
"ज्वाइन" "मूल डेटासेट (जैसे SELECT ... WHERE id IN (<subarray>)) के साथ सबर्रे मेंO(m lg n)

कोई भी विधि जो SQL के बाहर यादृच्छिक सबसेट उत्पन्न करती है, उसमें कम से कम यह जटिलता अवश्य होनी चाहिए। O(m lg n)BTREE की तुलना में ज्वाइन कोई भी तेज़ नहीं हो सकता (इसलिए O(m)अधिकांश इंजनों के लिए दावे काल्पनिक हैं) और फेरबदल नीचे से बंधा हुआ है nऔर m lg nयह स्पर्शोन्मुख व्यवहार को प्रभावित नहीं करता है।

पायथोनिक स्यूडोकोड में:

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

Question 10

Netezza में 3000 रैंडम रिकॉर्ड्स चुनें:

WITH IDS AS (
     SELECT ID
     FROM MYTABLE;
)

SELECT ID FROM IDS ORDER BY mt_random() LIMIT 3000

Question 11

प्रयत्न

SELECT TOP 10000 * FROM table ORDER BY NEWID()

क्या यह जटिल होने के बिना वांछित परिणाम देगा?

Question 12

Microsoft SQL सर्वर, PostgreSQL और Oracle (लेकिन MySQL या SQLite नहीं) जैसी कुछ बोलियों में, आप कुछ ऐसा कर सकते हैं

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

सिर्फ इसके (10000 rows)बिना न करने का कारण यह topहै कि TABLESAMPLEतर्क आपको एक बहुत ही सटीक संख्या में पंक्तियाँ देता है (जैसे कभी-कभी 75%, कभी-कभी 1.25% गुना), इसलिए आप अपनी इच्छित संख्या का सही चयन और चयन करना चाहते हैं। REPEATABLE (123)एक यादृच्छिक बीज उपलब्ध कराने के लिए है।

Question 13

शायद आप कर सकते थे

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