मारियाडीबी राउंड () बनाम ट्रंकेट ()

मारियाडीबी का एक ROUND() है फ़ंक्शन और एक TRUNCATE() फ़ंक्शन जो उनके तर्कों के सटीक मूल्य के आधार पर समान परिणाम या भिन्न परिणाम लौटा सकता है।

जैसा कि फ़ंक्शन के नाम से पता चलता है, ROUND() राउंड संख्या और TRUNCATE() छोटा करता है रेखावृत्त। किसी संख्या को छोटा करने से वह बिना कोई गोलाई किए सरलता से कट जाता है।

नीचे ROUND() . के बीच के अंतर पर एक संक्षिप्त विवरण दिया गया है और TRUNCATE() मारियाडीबी में।

अंतर

यहाँ संक्षेप में प्रत्येक फ़ंक्शन के बीच का अंतर है:

• ROUND() राउंड दशमलव स्थानों की एक निर्दिष्ट संख्या के लिए इसका तर्क। यह कभी-कभी परिणाम को गोल कर देगा, और कभी-कभी नहीं।
• TRUNCATE() बस छंटनी दशमलव स्थानों की एक निर्दिष्ट संख्या के लिए इसका तर्क। कोई गोलाई नहीं होती है।

वाक्यविन्यास और परिभाषाएं

सबसे पहले, यहां प्रत्येक फ़ंक्शन के सिंटैक्स और परिभाषाएं दी गई हैं।

ROUND()

ROUND() फ़ंक्शन का उपयोग निम्नलिखित दो तरीकों से किया जा सकता है:

ROUND(X)
ROUND(X,D)

ROUND() तर्क को गोल करें X करने के लिए D दशमलव स्थानों। राउंडिंग एल्गोरिथम X . के डेटा प्रकार पर निर्भर करता है ।

TRUNCATE()

TRUNCATE() फ़ंक्शन का उपयोग केवल एक सिंटैक्स के साथ किया जा सकता है:

TRUNCATE(X,D)

TRUNCATE() संख्या देता है X , को छोटा करके D . कर दिया गया है दशमलव स्थान।

उदाहरण

ROUND() . के बीच के अंतर को प्रदर्शित करने के लिए यहां तुलना की गई है और TRUNCATE() :

SELECT 
    TRUNCATE(3.6789, 2),
    ROUND(3.6789, 2);

परिणाम:

+---------------------+------------------+
| TRUNCATE(3.6789, 2) | ROUND(3.6789, 2) |
+---------------------+------------------+
|                3.67 |             3.68 |
+---------------------+------------------+

इस मामले में, ROUND() फ़ंक्शन ने संख्या को गोल कर दिया, क्योंकि अगला अंक (8 ) 5 . से बड़ा है .

TRUNCATE() दूसरी ओर फ़ंक्शन, बस निर्दिष्ट दशमलव स्थान पर संख्या को छोटा कर देता है। TRUNCATE() कोई गोलाई नहीं करता है। यह केवल निर्दिष्ट स्थान पर नंबर काट देता है।

दोनों फ़ंक्शन दशमलव स्थान के लिए एक ऋणात्मक मान स्वीकार करते हैं, और एक ही संबंधित तर्क लागू होता है:

SELECT 
    TRUNCATE(36789, -2),
    ROUND(36789, -2);

परिणाम:

+---------------------+------------------+
| TRUNCATE(36789, -2) | ROUND(36789, -2) |
+---------------------+------------------+
|               36700 |            36800 |
+---------------------+------------------+

समान परिणाम

दोनों फ़ंक्शन कभी-कभी एक ही परिणाम लौटा सकते हैं। यह सब पारित किए जा रहे तर्कों के मूल्य पर निर्भर करता है।

यहां एक उदाहरण दिया गया है जहां वे दोनों एक ही परिणाम देते हैं:

SELECT 
    TRUNCATE(3.6749, 2),
    ROUND(3.6749, 2);

परिणाम:

+---------------------+------------------+
| TRUNCATE(3.6749, 2) | ROUND(3.6749, 2) |
+---------------------+------------------+
|                3.67 |             3.67 |
+---------------------+------------------+

इस मामले में, ROUND() संख्या को गोल नहीं किया, क्योंकि अगला अंक (4 ) 5 . से कम था . इसलिए, दोनों परिणाम समान हैं।

द FLOOR() समारोह

दोनों फंक्शन FLOOR() . से अलग हैं फ़ंक्शन, जो सबसे बड़ा पूर्णांक मान देता है जो इसके तर्क से अधिक नहीं है। FLOOR() ROUND() . जैसे दूसरे तर्क को स्वीकार नहीं करता है और TRUNCATE() do (यह वैसे भी केवल एक पूर्णांक लौटाता है)।