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