SQL सर्वर में रैंड () नियतात्मक कैसे बनाएं?

RAND() SQL सर्वर में फ़ंक्शन 0 से 1 तक एक छद्म-यादृच्छिक फ्लोट मान देता है, अनन्य।

यह फ़ंक्शन नियतात्मक या गैर-नियतात्मक हो सकता है, यह इस बात पर निर्भर करता है कि इसे कैसे लागू किया जाता है।

नियतात्मक कार्य हमेशा इनपुट मानों के दिए गए सेट के लिए समान परिणाम लौटाते हैं और डेटाबेस की समान स्थिति देते हैं। नॉनडेटर्मिनिस्टिक फ़ंक्शंस इनपुट मानों के एक ही सेट के साथ एक अलग परिणाम लौटा सकते हैं और भले ही डेटाबेस स्थिति समान रहे।

RAND() फ़ंक्शन को दो तरीकों से बुलाया जा सकता है; बीज के साथ और बिना बीज के। यदि आप इसे बिना बीज के कहते हैं, तो यह अनिर्धारित है। यदि आप इसे बीज कहते हैं, तो यह नियतात्मक है।

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

लेकिन एक गॉचा है:कभी-कभी कॉल करना RAND() बीज के बिना है नियतात्मक। मैं इसे नीचे समझाता हूं।

सिंटैक्स

सबसे पहले, यहाँ सिंटैक्स है:

RAND ( [ seed ] )

वर्ग कोष्ठक का अर्थ है कि बीज तर्क वैकल्पिक है।

उदाहरण 1 - कोई बीज नहीं

यहां मैं RAND() call को कॉल करता हूं पांच बार बिना बीज के।

SELECT RAND() AS [No Seed]
UNION ALL
SELECT RAND()
UNION ALL
SELECT RAND()
UNION ALL
SELECT RAND()
UNION ALL
SELECT RAND()

परिणाम:

+-------------------+
| No Seed           |
|-------------------|
| 0.2054995913191   |
| 0.821844434880088 |
| 0.4204955495022   |
| 0.286702661673299 |
| 0.394385747185196 |
+-------------------+

प्रत्येक पंक्ति का एक अलग मान होता है।

उदाहरण 2 - बीज के साथ

यहां मैं वही क्वेरी चलाता हूं, सिवाय इसके कि मैं प्रत्येक फ़ंक्शन कॉल में एक ही बीज जोड़ता हूं।

SELECT RAND(100) AS [With Seed]
UNION ALL
SELECT RAND(100)
UNION ALL
SELECT RAND(100)
UNION ALL
SELECT RAND(100)
UNION ALL
SELECT RAND(100)

परिणाम:

+-------------------+
| With Seed         |
|-------------------|
| 0.715436657367485 |
| 0.715436657367485 |
| 0.715436657367485 |
| 0.715436657367485 |
| 0.715436657367485 |
+-------------------+

इस मामले में, सभी पंक्तियों का मान समान होता है।

उदाहरण 3 - एक ही प्रश्न में बीज और बिना बीज को मिलाएं (एकाधिक रैंड () कॉल)

RAND() . को कॉल करते समय आपको सावधान रहने की जरूरत है एक ही संबंध में कई बार। अगर आप RAND() . पर कॉल करते हैं एक निर्दिष्ट बीज मूल्य के साथ, RAND() . के सभी बाद के कॉल वरीयता प्राप्त RAND() . के आधार पर परिणाम उत्पन्न करें बुलाना।

तो आप अनजाने में सोच सकते हैं कि आप RAND() executing को क्रियान्वित कर रहे हैं अनिर्धारित रूप से जब वास्तव में आप नहीं हैं।

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

SELECT 
  RAND(100) AS [With Seed], 
  RAND() AS [No Seed], 
  RAND() AS [No Seed]
UNION ALL
SELECT 
  RAND(100) AS [With Seed], 
  RAND() AS [No Seed], 
  RAND() AS [No Seed]
UNION ALL
SELECT 
  RAND(100) AS [With Seed], 
  RAND() AS [No Seed], 
  RAND() AS [No Seed];

परिणाम:

+-------------------+------------------+--------------------+
| With Seed         | No Seed          | No Seed            |
|-------------------+------------------+--------------------|
| 0.715436657367485 | 0.28463380767982 | 0.0131039082850364 |
| 0.715436657367485 | 0.28463380767982 | 0.0131039082850364 |
| 0.715436657367485 | 0.28463380767982 | 0.0131039082850364 |
+-------------------+------------------+--------------------+

भले ही परिणामी मान सभी स्तंभों में भिन्न हो, प्रत्येक "कोई बीज नहीं" कॉल वास्तव में "बीज के साथ" कॉल पर आधारित था, और इसलिए, नियतात्मक।

अगर मैं फ़ंक्शन कॉल को शफ़ल करता हूँ, तो मुझे यह मिलता है।

SELECT 
  RAND() AS [No Seed], 
  RAND() AS [No Seed],
  RAND(100) AS [With Seed]
UNION ALL
SELECT 
  RAND() AS [No Seed], 
  RAND() AS [No Seed],
  RAND(100) AS [With Seed]
UNION ALL
SELECT 
  RAND() AS [No Seed], 
  RAND() AS [No Seed],
  RAND(100) AS [With Seed];

परिणाम:

+------------------+--------------------+-------------------+
| No Seed          | No Seed            | With Seed         |
|------------------+--------------------+-------------------|
| 0.28769876521071 | 0.100505471175005  | 0.715436657367485 |
| 0.28463380767982 | 0.0131039082850364 | 0.715436657367485 |
| 0.28463380767982 | 0.0131039082850364 | 0.715436657367485 |
+------------------+--------------------+-------------------+