मैं सोशल नेटवर्क ट्रैकिंग एप्लिकेशन पर काम कर रहा हूं। यहां तक ​​कि जॉइन भी उचित अनुक्रमण के साथ ठीक काम करता है। लेकिन जब मैं क्लॉज द्वारा ऑर्डर जोड़ता हूं तो कुल क्वेरी को निष्पादित करने में 100 गुना अधिक समय लगता है। निम्न क्वेरी मैं खंड द्वारा आदेश के बिना twitter_users प्राप्त करने के लिए प्रयोग किया जाता है।

SELECT DISTINCT  `tracked_twitter`.id
FROM tracked_twitter
INNER JOIN  `twitter_content` ON  `tracked_twitter`.`id` = `twitter_content`.`tracked_twitter_id` 
INNER JOIN  `tracker_twitter_content` ON  `twitter_content`.`id` = `tracker_twitter_content`.`twitter_content_id` 
AND  `tracker_twitter_content`.`tracker_id` =  '88'
LIMIT 20

पंक्तियाँ दिखा रहा है 0 - 19 (कुल 20, क्वेरी में 0.0714 सेकंड का समय लगा)

लेकिन जब मैं खंड द्वारा आदेश जोड़ता हूं (अनुक्रमित कॉलम पर)

SELECT DISTINCT  `tracked_twitter`.id
FROM tracked_twitter
INNER JOIN  `twitter_content` ON  `tracked_twitter`.`id` =  `twitter_content`.`tracked_twitter_id` 
INNER JOIN  `tracker_twitter_content` ON  `twitter_content`.`id` =  `tracker_twitter_content`.`twitter_content_id` 
AND  `tracker_twitter_content`.`tracker_id` =  '88'
ORDER BY tracked_twitter.followers_count DESC 
LIMIT 20

पंक्तियाँ दिखा रहा है 0 - 19 (कुल 20, क्वेरी में 13.4636 सेकंड का समय लगा)

समझाना यहां छवि विवरण दर्ज करें

जब मैं अकेले इसकी तालिका में खंड द्वारा आदेश लागू करता हूं तो इसमें ज्यादा समय नहीं लगता है

SELECT * FROM `tracked_twitter` WHERE 1 order by `followers_count` desc limit 20

पंक्तियाँ दिखा रहा है 0 - 19 (कुल 20, क्वेरी में 0.0711 सेकंड का समय लगा) [फॉलोअर्स_काउंट: 68236387 - 10525612]

तालिका निर्माण क्वेरी इस प्रकार है

CREATE TABLE IF NOT EXISTS `tracked_twitter` (
    `id` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
    `handle` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
    `name` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
    `location` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
    `description` text COLLATE utf8_unicode_ci,
    `profile_image` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
    `followers_count` int(11) NOT NULL,
    `is_influencer` tinyint(1) NOT NULL DEFAULT '0',
    `created_at` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',
    `updated_at` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00',
    `gender` enum('Male','Female','Other') COLLATE utf8_unicode_ci 
     DEFAULT NULL,
     PRIMARY KEY (`id`),
     KEY `followers_count` (`followers_count`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

इसलिए जब मैं इसे अपनी टेबल पर निष्पादित करता हूं तो अच्छी तरह से काम करके क्वेरी और ऑर्डर को धीमा नहीं किया। तो मैं प्रदर्शन में सुधार कैसे कर सकता हूं?

अपडेट 1

@GordonLinoff विधि हल करती है यदि मुझे केवल मूल तालिका से परिणाम सेट की आवश्यकता है। मैं क्या जानना चाहता हूं प्रति व्यक्ति ट्वीट्स की संख्या (Twitter_content की गिनती जो tracked_twitter तालिका से मेल खाती है)। मैं इसे कैसे संशोधित कर सकता हूं? और अगर मैं ट्वीट सामग्री पर गणित के कार्य करना चाहता हूं तो मैं इसे कैसे कर सकता हूं ??

SELECT  `tracked_twitter` . * , COUNT( * ) AS twitterContentCount, retweet_count + favourite_count + reply_count AS engagement
FROM  `tracked_twitter` 
INNER JOIN  `twitter_content` ON  `tracked_twitter`.`id` =  `twitter_content`.`tracked_twitter_id` 
INNER JOIN  `tracker_twitter_content` ON  `twitter_content`.`id` =  `tracker_twitter_content`.`twitter_content_id` 
WHERE  `is_influencer` !=  '1'
AND  `tracker_twitter_content`.`tracker_id` =  '88'
AND  `tracked_twitter_id` !=  '0'
GROUP BY  `tracked_twitter`.`id` 
ORDER BY twitterContentCount DESC 
LIMIT 20 
OFFSET 0
7
Tamizharasan 5 सितंबर 2017, 13:57

3 जवाब

सबसे बढ़िया उत्तर

distinct से छुटकारा पाने का प्रयास करें। यह एक प्रदर्शन हत्यारा है। मुझे यकीन नहीं है कि आपकी पहली क्वेरी जल्दी क्यों काम करती है; शायद MySQL इसे दूर अनुकूलित करने के लिए पर्याप्त स्मार्ट है।

मैं कोशिश करूँगा:

SELECT tt.id
FROM tracked_twitter tt
WHERE EXISTS (SELECT 1
              FROM twitter_content tc INNER JOIN  
                   tracker_twitter_content ttc
                   ON  tc.id =  ttc.twitter_content_id
              WHERE  ttc.tracker_id =  88 AND
                     tt.id =  tc.tracked_twitter_id
             )
ORDER BY tt.followers_count DESC ;

इस संस्करण के लिए, आप इन पर अनुक्रमित करना चाहते हैं: tracked_twitter(followers_count, id), twitter_content(tracked_twitter_id, id), और tracker_twitter_content(twitter_content_id, tracker_id).

4
Gordon Linoff 5 सितंबर 2017, 14:05

जनक तालिका सीमा के साथ ब्रैकेट पर रखें

SELECT DISTINCT  `tracked_twitter`.id FROM
(SELECT id,followers_count  FROM tracked_twitter ORDER BY followers_count DESC 
LIMIT 20) AS tracked_twitter
INNER JOIN  `twitter_content` ON  `tracked_twitter`.`id` =  `twitter_content`.`tracked_twitter_id` 
INNER JOIN  `tracker_twitter_content` ON  `twitter_content`.`id` =  `tracker_twitter_content`.`twitter_content_id` 
AND  `tracker_twitter_content`.`tracker_id` =  '88'
ORDER BY tracked_twitter.followers_count DESC 
1
Lalabhai Patel 5 सितंबर 2017, 14:09

मुख्य समस्या यह है कि यहां तक ​​कि आपके पास अपेक्षाकृत कुछ पंक्तियाँ हैं, आप varchar(255) COLLATE utf8_unicode_ci का उपयोग प्राथमिक कुंजी (पूर्णांक के बजाय) के रूप में करते हैं और इसलिए अन्य तालिकाओं में विदेशी कुंजी के रूप में। मुझे संदेह है कि वही समस्या twitter_content.id के साथ है। यह बहुत लंबी स्ट्रिंग तुलनाओं का कारण बनता है और अस्थायी तालिकाओं के लिए बहुत अधिक अतिरिक्त मेमोरी जमा करता है।

प्रश्न के संबंध में, हाँ, यह एक प्रश्न होना चाहिए जो followers_count अनुक्रमणिका के साथ चलता है और संबंधित तालिकाओं के लिए स्थिति की जांच करता है। यह गॉर्डन लिनॉफ के सुझाव के अनुसार या सूचकांक संकेतों का उपयोग करके किया जा सकता है।

1
newtover 5 सितंबर 2017, 14:45