ऐसे डेटा टाइप जिनके साथ 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"}