MySQL। एक क्वेरी में यादृच्छिक स्ट्रिंग्स का चयन करें

हमारे पास क्या है?

एक कमजोर लैपटॉप, कई मिलियन पंक्तियों वाली एक तालिका है, और आपको एक क्वेरी में अलग-अलग संख्या में यादृच्छिक पंक्तियों को चुनने की आवश्यकता है। इसके अलावा नमूने हमें रुचि नहीं है।

तालिका (परीक्षण) में निम्नलिखित संरचना है:

• - pk_id (प्राथमिक कुंजी)
• - आईडी (विभिन्न संख्याओं से भरा क्षेत्र)
• - मान (रैंड से भरा क्षेत्र)

प्राथमिक कुंजी में कोई छेद नहीं है और 1 से शुरू होता है।

उत्पादन के तरीके

1. आदेश द्वारा रैंड + सीमा

   
   
   
   एक पंक्ति प्राप्त करना:
   

   SELECT pk_id FROM test ORDER BY rand() LIMIT 1 

   
   MySQL औसत लीड समय 6.150 सेकंड है
   
   आइए 100 प्रविष्टियां लेने का प्रयास करें
   

    SELECT pk_id FROM test ORDER BY rand() LIMIT 100 

   
   औसत लीड समय 6.170-6.180 सेकंड
   यही है, 1 और 100 यादृच्छिक तार प्राप्त करने के बीच का समय महत्वपूर्ण नहीं है।
   
   

2. COUNT * रैंड ()

   
   
   
   एक पंक्ति प्राप्त करना:
   

    SELECT t.pk_id FROM test as t, (SELECT ROUND(COUNT(pk_id)*rand()) as rnd FROM test LIMIT 1) t WHERE t.pk_id = rnd 

   
   साथ

    ROUND(COUNT(pk_id)*rand()) 

   हमें तालिका में पंक्तियों की संख्या से एक यादृच्छिक संख्या मिलती है।
   इसके बाद, हम अपने यादृच्छिक संख्या के लिए एक उपनाम "रैंड" असाइन करते हैं और इसे pk_id के साथ समकक्ष तुलना के लिए WHERE में उपयोग करते हैं।
   औसत लीड समय - 1.04 सेकंड
   अगला, आपको इस अनुरोध को थोड़ा संशोधित करने की आवश्यकता है ताकि आप कई लाइनों को खींच सकें।
   हमारे उप-क्षेत्र में कुछ और फ़ील्ड जोड़ें और चेक को "=" से IN में बदल दें
   

    SELECT t.pk_id FROM test as t, (SELECT ROUND(COUNT(pk_id)*rand()) as rnd, ROUND(COUNT(pk_id)*rand()) as rnd2, ROUND(COUNT(pk_id)*rand()) as rnd3 FROM test LIMIT 1) t WHERE t.pk_id IN (rnd,rnd2,rnd3) 

   
   औसत लीड समय 1.163 सेकंड है।
   प्राप्त पंक्तियों की संख्या में वृद्धि के साथ, क्वेरी निष्पादन का समय काफी बढ़ जाता है।
   100 लाइनों के बारे में, यह सोचना भी डरावना है :)
   
   

3. INFORMATION_SCHEMA + सीमा

   
   
   
   एक पंक्ति प्राप्त करना:
   

    SELECT t.pk_id FROM test as t, (SELECT ROUND((SELECT table_rows as tr FROM information_schema.tables WHERE table_name = 'test') *rand()) as rnd FROM test LIMIT 1) tmp WHERE t.pk_id = rnd 

   
   उपशम का उपयोग करते हुए, हम कुल फ़ंक्शन COUNT का उपयोग किए बिना तालिका 'परीक्षण' में पंक्तियों की संख्या प्राप्त करते हैं और आगे की तुलना विधि 2 में होती है।
   औसत लीड समय - 0.042 सेकंड
   न्यूनतम रनटाइम 0.003 सेकंड है।
   आइए कोशिश करें कि 100 लाइनें मिलें:
   

    SELECT t.pk_id FROM test as t, (SELECT ROUND((SELECT table_rows as tr FROM information_schema.tables WHERE table_name = 'test') *rand()) as rnd FROM test LIMIT 100) tmp WHERE t.pk_id in (rnd) ORDER BY pk_id 

   
   WHERE "=" को IN में बदलें और सबक्लेरी द्वारा लौटी हुई पंक्तियों की सीमा को 100 में बदलें।
   औसत नेतृत्व समय - 0.047 सेकंड
   1000 रिकॉर्ड प्राप्त करने का समय - 0.053 सेकंड
   10,000 रिकॉर्ड ~ 0.21 सेकंड प्राप्त करने का समय
   और अंत में, हम 1.9 सेकंड में 100,000 रिकॉर्ड लेते हैं
   इस दृष्टिकोण का नुकसान यह है कि INFORMATION_SCHEMA से पंक्तियों की परिणामी संख्या COUNT (*) से थोड़ी बड़ी है और इसलिए 100,000 पंक्तियों की वापसी के दौरान 7-8 पंक्तियाँ खो जाती हैं। 1-100 पर, यह व्यावहारिक रूप से अनुपस्थित है (बड़ी तालिका, कम मौका)। लेकिन आप हमेशा पुनर्बीमा के लिए 1-2 लाइनें अधिक ले सकते हैं :)
   
   

4. MAX * रैंड ()

   
   एक पंक्ति प्राप्त करना:
   

    SELECT t.pk_id FROM test as t, (SELECT ROUND((SELECT MAX(pk_id) FROM test) *rand()) as rnd FROM test LIMIT 1) tmp WHERE t.pk_id = rnd 

   
   औसत लीड समय - 0.001 सेकंड
   100 लाइनें प्राप्त करना:
   

    SELECT t.pk_id FROM test as t, (SELECT ROUND((SELECT MAX(pk_id) FROM test) *rand()) as rnd FROM test LIMIT 100) tmp WHERE t.pk_id in (rnd) ORDER BY pk_id 

   
   औसत लीड समय - 0.003 सेकंड
   
   सबसे तेज़ तरीका, पिछले वाले के सापेक्ष।
   

निष्कर्ष

• पहला तरीका अच्छा है कि किसी भी मामले में यह आपके लिए एक यादृच्छिक स्ट्रिंग लौटाएगा, चाहे खेतों में छेद हो और उनका प्रारंभिक मूल्य हो, लेकिन सबसे धीमा
• दूसरी विधि उन तालिकाओं में बहुत बेहतर है जहां कोई छेद नहीं हैं। यह पहली विधि (एक पंक्ति को वापस करने पर) की तुलना में 6 गुना तेज काम करता है।
• तीसरी विधि का उपयोग आपके स्वयं के जोखिम और जोखिम पर किया जा सकता है (जो बहुत ही महत्वहीन है), क्योंकि आप एक पंक्ति (रों) के साथ एक पंक्ति (मान) को लगभग 1 के रूप में खो सकते हैं। संभवतया, पहली पंक्ति की तुलना में एक पंक्ति की वापसी गति 150 मीटर से भिन्न होती है।
  यदि आप 100 पंक्तियाँ नहीं, बल्कि 99 पर लौटे हैं, तो आप एक बार फिर सर्वर को अनुरोध भेज सकते हैं।
• चौथा तरीका है सबसे तेज और 6000 गुना तेज ORDER BY रैंड ()

UPD: तालिका में छेद के मामले में, दूसरी और तीसरी तरह से एक पंक्ति में लौटते समय, आप एक बराबर चेक नहीं कर सकते हैं लेकिन> = और LIMIT 1 जोड़ें। तब मान "छेद" में गिर जाने पर भी वापस कर दिया जाएगा।
इस टिप्पणी के लिए धन्यवाद xel ।
UPD2: 4 प्राप्त करने का तरीका जोड़ा गया। इस विचार के लिए धन्यवाद smagen ।