मारियाडीबी राउंड () बनाम फ्लोर ()

मारियाडीबी का एक ROUND() है फ़ंक्शन और एक FLOOR() फ़ंक्शन जो कुछ मायनों में समान हैं, लेकिन अन्य तरीकों से काफी भिन्न हैं।

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

अंतर

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

• ROUND() अपने तर्क को दशमलव स्थानों की एक निर्दिष्ट संख्या तक पूर्णांकित करता है।
• FLOOR() सबसे बड़ा पूर्णांक मान देता है जो इसके तर्क से बड़ा नहीं है।

सिंटैक्स

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

ROUND()

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

ROUND(X)
ROUND(X,D)

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

FLOOR()

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

FLOOR(X)

FLOOR() सबसे बड़ा पूर्णांक मान देता है जो X . से बड़ा नहीं है ।

अंतर का उदाहरण

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

SELECT 
    FLOOR(3.6789),
    ROUND(3.6789);

परिणाम:

+---------------+---------------+
| FLOOR(3.6789) | ROUND(3.6789) |
+---------------+---------------+
|             3 |             4 |
+---------------+---------------+

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

FLOOR() दूसरी ओर फ़ंक्शन, बस सबसे बड़ा पूर्णांक मान लौटाता है जो तर्क से बड़ा नहीं है (3.6789 )।

दूसरा तर्क

एक और अंतर यह है कि ROUND() एक वैकल्पिक दूसरा तर्क स्वीकार करता है, जबकि FLOOR() नहीं।

दूसरा तर्क आपको यह निर्दिष्ट करने की अनुमति देता है कि संख्या को कितने दशमलव स्थानों तक गोल करना है।

उदाहरण

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

परिणाम:

+---------------+------------------+
| FLOOR(3.6789) | ROUND(3.6789, 2) |
+---------------+------------------+
|             3 |             3.68 |
+---------------+------------------+

समान परिणाम का उदाहरण

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

उदाहरण के लिए, यदि हम मानों के सामने ऋणात्मक चिह्न लगाते हैं, तो हमें वही परिणाम प्राप्त होता है:

SELECT 
    FLOOR(-3.6789),
    ROUND(-3.6789);

परिणाम:

+----------------+----------------+
| FLOOR(-3.6789) | ROUND(-3.6789) |
+----------------+----------------+
|             -4 |             -4 |
+----------------+----------------+

इसका मतलब यह नहीं है कि एक नकारात्मक मूल्य हमेशा एक ही परिणाम देता है - ऐसा नहीं है। यह सब प्रदान किए जा रहे वास्तविक मूल्यों और ROUND() . द्वारा किए जाने वाले पूर्णांकन पर निर्भर करता है ।

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

SELECT 
    FLOOR(-3.3739),
    ROUND(-3.3739);

परिणाम:

+----------------+----------------+
| FLOOR(-3.3739) | ROUND(-3.3739) |
+----------------+----------------+
|             -4 |             -3 |
+----------------+----------------+

और यहां एक उदाहरण दिया गया है जहां सकारात्मक मान समान परिणाम देते हैं:

SELECT 
    FLOOR(3.3739),
    ROUND(3.3739);

परिणाम:

+---------------+---------------+
| FLOOR(3.3739) | ROUND(3.3739) |
+---------------+---------------+
|             3 |             3 |
+---------------+---------------+

द TRUNCATE() समारोह

दोनों फंक्शन TRUNCATE() . से अलग हैं फ़ंक्शन, जो मान को दशमलव स्थानों की दी गई संख्या में आसानी से छोटा कर देता है।