मारियाडीबी बेंचमार्क () समझाया गया

मारियाडीबी में, BENCHMARK() एक अंतर्निहित फ़ंक्शन है जो एक अभिव्यक्ति को निर्दिष्ट संख्या में निष्पादित करता है।

इसका उपयोग समय के लिए किया जा सकता है कि मारियाडीबी अभिव्यक्ति को कितनी जल्दी संसाधित करता है।

नतीजा हमेशा 0 होता है . फ़ंक्शन को mysql कमांड लाइन टूल के भीतर उपयोग करने का इरादा है, जो क्वेरी निष्पादन समय की रिपोर्ट करता है।

सिंटैक्स

वाक्य रचना इस प्रकार है:

BENCHMARK(count,expr)

जहां count जितनी बार आप चाहते हैं expr . है चलाने के लिए।

उदाहरण 1

प्रदर्शित करने के लिए यहां एक उदाहरण दिया गया है:

SELECT BENCHMARK(2, SLEEP(2));

परिणाम:

+------------------------+
| BENCHMARK(2, SLEEP(2)) |
+------------------------+
|                      0 |
+------------------------+
1 row in set (4.015 sec)

जैसी उम्मीद थी, 0 लौटाया गया। हालांकि, हम जिस चीज में रुचि रखते हैं वह है क्वेरी निष्पादन समय।

यहाँ मैंने SLEEP() . का उपयोग किया है 2 सेकंड के लिए सोने के लिए कार्य करें। इस फ़ंक्शन का उपयोग करने से सामान्य रूप से कथन को निष्पादित होने में लगभग 2 सेकंड का समय लगता है।

हालांकि, इस मामले में मैंने 2 . पास कर लिया है BENCHMARK() . के पहले तर्क के रूप में . जिसके कारण SLEEP() दो बार निष्पादित करने के लिए फ़ंक्शन, जिसके कारण BENCHMARK() क्रियान्वित होने में लगभग 4 सेकंड लगते हैं (सटीक होने के लिए 4.015 सेकंड)।

अगर हम पहले तर्क को 3 . तक बढ़ा देते हैं तो यहां क्या होता है? :

SELECT BENCHMARK(3, SLEEP(2));

परिणाम:

+------------------------+
| BENCHMARK(3, SLEEP(2)) |
+------------------------+
|                      0 |
+------------------------+
1 row in set (6.012 sec)

इस बार SLEEP() फ़ंक्शन को तीन बार निष्पादित किया गया था, और इसलिए BENCHMARK() निष्पादित करने में केवल 6 सेकंड से अधिक समय लगा।

उदाहरण 2

यहां एक उदाहरण दिया गया है जो ENCODE() . का उपयोग करता है एक पासवर्ड (दूसरा तर्क) के साथ एक स्ट्रिंग (पहला तर्क) को एन्कोड करने के लिए कार्य करें:

SELECT BENCHMARK(100000, ENCODE('Homer', 'Symptom'));

परिणाम:

+-----------------------------------------------+
| BENCHMARK(100000, ENCODE('Homer', 'Symptom')) |
+-----------------------------------------------+
|                                             0 |
+-----------------------------------------------+
1 row in set (0.016 sec)

हम देख सकते हैं कि ऑपरेशन को पूरा होने में 0.016 सेकंड का समय लगा।

आइए पहले तर्क को 100,000 से बढ़ाकर 1,000,000 कर दें और देखें कि यह निष्पादन समय को कैसे प्रभावित करता है।

SELECT BENCHMARK(1000000, ENCODE('Homer', 'Symptom'));

परिणाम:

+------------------------------------------------+
| BENCHMARK(1000000, ENCODE('Homer', 'Symptom')) |
+------------------------------------------------+
|                                              0 |
+------------------------------------------------+
1 row in set (0.118 sec)

इस बार इसे चलने में अधिक समय लगा।

शून्य तर्क

यदि पहला तर्क null है , फिर null लौटा दिया गया है:

SELECT BENCHMARK(null, ENCODE('Homer', 'Symptom'));

परिणाम:

+---------------------------------------------+
| BENCHMARK(null, ENCODE('Homer', 'Symptom')) |
+---------------------------------------------+
|                                        NULL |
+---------------------------------------------+
1 row in set (0.007 sec)

लेकिन अगर केवल दूसरा तर्क null है , फिर 0 लौटा दिया गया है:

SELECT BENCHMARK(100000, null);

परिणाम:

+-------------------------+
| BENCHMARK(100000, null) |
+-------------------------+
|                       0 |
+-------------------------+
1 row in set (0.002 sec)

तर्कों की अमान्य संख्या

BENCHMARK() को कॉल करना बिना तर्क के, या तर्कों की गलत संख्या के साथ, एक त्रुटि उत्पन्न होती है:

SELECT BENCHMARK();

परिणाम:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'BENCHMARK'

और:

SELECT BENCHMARK(1, 2, 3);

परिणाम:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'BENCHMARK'