ऐसे डेटा टाइप जिनके साथ PostgreSQL कनेक्टर काम करता है

किसी अरे में, उसके एलिमेंट के तौर पर कोई अन्य अरे वैल्यू नहीं हो सकती.

कलेक्शन में, एलिमेंट को असाइन की गई पोज़िशन में ही रखा जाता है. दो या उससे ज़्यादा ऐरे को क्रम से लगाने पर, ऐरे को उनके एलिमेंट की वैल्यू के आधार पर क्रम से लगाया जाता है.

दो ऐरे की तुलना करते समय, हर ऐरे के पहले एलिमेंट की तुलना की जाती है. अगर पहले एलिमेंट बराबर हैं, तो दूसरे एलिमेंट की तुलना की जाती है. ऐसा तब तक होता रहता है, जब तक अंतर नहीं मिल जाता. अगर किसी ऐरे में तुलना करने के लिए एलिमेंट नहीं बचे हैं, लेकिन उस तक एलिमेंट बराबर हैं, तो छोटे ऐरे को लंबे ऐरे से पहले क्रम में लगाया जाता है.

उदाहरण के लिए, [1, 2, 3] < [1, 2, 3, 1] < [2]. ऐरे [2] के पहले एलिमेंट की वैल्यू सबसे ज़्यादा है. [1, 2, 3] ऐरे में, [1, 2, 3, 1] के पहले तीन एलिमेंट के बराबर एलिमेंट हैं, लेकिन यह ऐरे छोटा है.

यह किसी दस्तावेज़ में एम्बेड किए गए ऑब्जेक्ट को दिखाता है. इंडेक्स होने के बाद, सब-फ़ील्ड पर क्वेरी की जा सकती है. अगर इस वैल्यू को इंडेक्स करने से बाहर रखा जाता है, तो सभी सबफ़ील्ड को भी इंडेक्स करने से बाहर रखा जाता है.

कुंजियों का क्रम हमेशा क्रम से लगाया जाता है. उदाहरण के लिए, अगर आपने लिखा है कि {c: "foo", a: "bar", b: "qux"} मैप को बटन के हिसाब से क्रम में लगाया गया है और इसे {a: "bar", b: "qux", c: "foo"} के तौर पर सेव किया गया है.

मैप फ़ील्ड को की के हिसाब से क्रम में लगाया जाता है और की-वैल्यू पेयर के हिसाब से उनकी तुलना की जाती है. सबसे पहले, की की तुलना की जाती है और फिर वैल्यू की. अगर पहले की-वैल्यू पेयर बराबर हैं, तो अगले की-वैल्यू पेयर की तुलना की जाती है. अगर दो मैप में एक जैसे सभी कीवर्ड-वैल्यू पेयर हैं, तो मैप की लंबाई को ध्यान में रखा जाता है. उदाहरण के लिए, नीचे दिए गए मैप बढ़ते क्रम में हैं:

{a: "aaa", b: "baz"}
{a: "foo", b: "bar"}
{a: "foo", b: "bar", c: "qux"}
{a: "foo", b: "baz"}
{b: "aaa", c: "baz"}
{c: "aaa"}