डिफ़ॉल्ट क्रम के आधार पर 2 सेट में शामिल हों

अब, असली . का उत्तर देने के लिए प्रश्न जो टिप्पणियों में सामने आया था, जो कुछ इस तरह प्रतीत होता है:

इससे निपटने के कुछ तरीके हैं:

• यदि और केवल यदि सरणियाँ समान लंबाई की हों, तो एकाधिक unnest . का उपयोग करें SELECT . में काम करता है खंड (एक पदावनत दृष्टिकोण जिसका उपयोग केवल पिछड़े संगतता के लिए किया जाना चाहिए);

• generate_subscripts का उपयोग करें सरणियों पर लूप करने के लिए;

• generate_series Use का उपयोग करें array_lower . के विरुद्ध उपश्रेणियों पर और array_upper अनुकरण करने के लिए generate_subscripts यदि आपको generate_subscripts . के लिए बहुत पुराने संस्करणों का समर्थन करने की आवश्यकता है;

• उस आदेश पर भरोसा करते हुए कि unnest मेरे अन्य उत्तर में और जैसा कि नीचे दिखाया गया है - में टुपल्स देता है और उम्मीद करता है। यह काम करेगा, लेकिन भविष्य के संस्करणों में काम करने की गारंटी नहीं है।

• WITH ORDINALITY का उपयोग करें PostgreSQL 9.4 में जोड़ा गया कार्यक्षमता (यह भी देखें इसकी पहली पोस्टिंग ) unnest . के लिए एक पंक्ति संख्या प्राप्त करने के लिए जब 9.4 बाहर आता है।

• बहु-सरणी का उपयोग करें UNNEST , जो SQL-मानक है लेकिन जो PostgreSQL है अभी तक समर्थन नहीं करता ।

तो, मान लें कि हमारे पास कार्य है arraypair सरणी मापदंडों के साथ a और b :

CREATE OR REPLACE FUNCTION arraypair (a integer[], b text[]) 
RETURNS TABLE (col_a integer, col_b text) AS $$
  -- blah code here blah
$$ LANGUAGE whatever IMMUTABLE;

और इसे इस प्रकार कहा जाता है:

SELECT * FROM arraypair( ARRAY[1,2,3,4,5,6,7], ARRAY['a','b','c','d','e','f','g'] );

संभावित कार्य परिभाषाएँ होंगी:

एसआरएफ-इन-SELECT (बहिष्कृत)

CREATE OR REPLACE FUNCTION arraypair (a integer[], b text[])
RETURNS TABLE (col_a integer, col_b text) AS $$
    SELECT unnest(a), unnest(b);
$$ LANGUAGE sql IMMUTABLE;

यदि सरणियाँ लंबाई में समान नहीं हैं, तो विचित्र और अप्रत्याशित परिणाम देगा; SELECT . में सेट रिटर्निंग फ़ंक्शंस और उनके गैर-मानक उपयोग पर दस्तावेज़ देखें क्यों, और वास्तव में क्या होता है, यह जानने के लिए सूची बनाएं।

generate_subscripts

यह संभवतः सबसे सुरक्षित विकल्प है:

CREATE OR REPLACE FUNCTION arraypair (a integer[], b text[])
RETURNS TABLE (col_a integer, col_b text) AS $$
    SELECT
       a[i], b[i]
    FROM generate_subscripts(CASE WHEN array_length(a,1) >= array_length(b,1) THEN a::text[] ELSE b::text[] END, 1) i;
$$ LANGUAGE sql IMMUTABLE;

यदि सरणियाँ असमान लंबाई की हैं, जैसा कि लिखा गया है, तो यह छोटे तत्वों के लिए अशक्त तत्व लौटाएगा, इसलिए यह पूर्ण बाहरी जुड़ाव की तरह काम करता है। आंतरिक-जुड़ने जैसा प्रभाव प्राप्त करने के लिए मामले की भावना को उलट दें। फ़ंक्शन मानता है कि सरणियाँ एक-आयामी हैं और वे अनुक्रमणिका 1 से शुरू होती हैं। यदि एक संपूर्ण सरणी तर्क NULL है तो फ़ंक्शन NULL देता है।

एक अधिक सामान्यीकृत संस्करण PL/PgSQL में लिखा जाएगा और array_ndims(a) = 1 की जांच करेगा। , चेक करें array_lower(a, 1) = 1 , अशक्त सरणियों के लिए परीक्षण करें, आदि। मैं इसे आप पर छोड़ता हूँ।

जोड़ी-वार रिटर्न की उम्मीद:

यह काम करने की गारंटी नहीं है, लेकिन PostgreSQL के वर्तमान क्वेरी निष्पादक के साथ करता है:

CREATE OR REPLACE FUNCTION arraypair (a integer[], b text[])
RETURNS TABLE (col_a integer, col_b text) AS $$
 WITH
    rn_c1(rn, col) AS (
      SELECT row_number() OVER (), c1.col
      FROM unnest(a) c1(col) 
    ),
    rn_c2(rn, col) AS (
      SELECT row_number() OVER (), c2.col
      FROM unnest(b) c2(col)
    )
    SELECT
      rn_c1.col AS c1, 
      rn_c2.col AS c2
    FROM rn_c1 
    INNER JOIN rn_c2 ON (rn_c1.rn = rn_c2.rn);
$$ LANGUAGE sql IMMUTABLE;

मैं generate_subscripts . का उपयोग करने पर विचार करूंगा ज्यादा सुरक्षित।

बहु-तर्क unnest :

यह चाहिए काम करते हैं, लेकिन इसलिए नहीं कि PostgreSQL का unnest एकाधिक इनपुट सरणियों को स्वीकार नहीं करता (अभी तक):

SELECT * FROM unnest(a,b);