[SQL] 그 콤바인 두 배열의 PostgreSQL에 우편 () 함수와 같은 뭔가인가?

그 콤바인 두 배열의 PostgreSQL에 우편 () 함수와 같은 뭔가인가?

I PostgreSQL의 동일한 길이의 두 배열의 값을 갖는다 :

{A, B, C} 및 {D, E, F}

나는로 결합하고 싶습니다

{{A, D}, {B, E}, {C, F}}

그렇게 할 수있는 방법이 있습니까?

해결법

1. ==============================

   1.포스트 그레스 9.3 또는 이전 버전에 대해 다음과 데모를 고려 :

   포스트 그레스 9.3 또는 이전 버전에 대해 다음과 데모를 고려 :

   SELECT ARRAY[a,b] AS ab
   FROM  (
      SELECT unnest('{a,b,c}'::text[]) AS a
            ,unnest('{d,e,f}'::text[]) AS b
       ) x;
   

   결과:

     ab
   -------
    {a,d}
    {b,e}
    {c,f}
   

   두 배열이 병렬로 unnest에 같은 수의 원소가 있어야합니다, 또는 당신이 십자가 대신에 가입 얻을 수 있습니다.

   당신은 당신이 원하는 경우, 함수에이 포장 할 수 있습니다 :

   CREATE OR REPLACE FUNCTION zip(anyarray, anyarray)
     RETURNS SETOF anyarray LANGUAGE SQL AS
   $func$
   SELECT ARRAY[a,b] FROM (SELECT unnest($1) AS a, unnest($2) AS b) x;
   $func$;
   

   요구:

   SELECT zip('{a,b,c}'::text[],'{d,e,f}'::text[]);
   

   같은 결과.

   당신은 하나의 2 차원 배열로 배열의 새로운 세트를 집계하려면 지금, 그것은 더 복잡해진다.

   SELECT ARRAY (SELECT ...)

   또는:

   SELECT array_agg(ARRAY[a,b]) AS ab
   FROM  (
      SELECT unnest('{a,b,c}'::text[]) AS a
            ,unnest('{d,e,f}'::text[]) AS b
       ) x

   또는:

   SELECT array_agg(ARRAY[ARRAY[a,b]]) AS ab
   FROM  ...

   동일한 오류 메시지의 모든 결과 (9.1.5 PG 테스트)한다 :

   우리는이 밀접하게 관련 질문 하에서 작동하지만이 주위에 방법이있다.  사용자 정의 집계 함수를 만듭니다 :

   CREATE AGGREGATE array_agg_mult (anyarray) (
       SFUNC    = array_cat
      ,STYPE    = anyarray
      ,INITCOND = '{}'
   );
   

   그리고 다음과 같이 사용 :

   SELECT array_agg_mult(ARRAY[ARRAY[a,b]]) AS ab
   FROM  (
      SELECT unnest('{a,b,c}'::text[]) AS a
            ,unnest('{d,e,f}'::text[]) AS b
       ) x
   

   결과:

   {{a,d},{b,e},{c,f}}
   

   추가 ARRAY [] 층주의! 그것없이 그냥 :

   SELECT array_agg_mult(ARRAY[a,b]) AS ab
   FROM ...
   

   당신이 얻을 :

   {a,d,b,e,c,f}
   

   어떤 다른 목적을 위해 유용 할 수 있습니다.

   다른 기능을 롤 :

   CREATE OR REPLACE FUNCTION zip2(anyarray, anyarray)
     RETURNS SETOF anyarray LANGUAGE SQL AS
   $func$
   SELECT array_agg_mult(ARRAY[ARRAY[a,b]])
   FROM (SELECT unnest($1) AS a, unnest($2) AS b) x;
   $func$;
   

   요구:

   SELECT zip2('{a,b,c}'::text[],'{d,e,f}'::text[]); -- or any other array type
   

   결과:

   {{a,d},{b,e},{c,f}}
   

   구조 또는 병렬 unnest 여러 배열을 얻어 갱신 unnest ()로부터의 열을 사용한다. 각각은 서로 다른 길이를 가질 수있다. 당신은 (문서 당) 수 :

   이 간단하고 명료 한 변형을 사용합니다 :

   SELECT ARRAY[a,b] AS ab
   FROM   unnest('{a,b,c}'::text[] 
               , '{d,e,f}'::text[]) x(a,b);
   

   선박 (배열 식) array_agg :

   이 드롭 인 교체 상당히 빠른 C로 구현 내 사용자 정의 집계 함수 array_agg_mult ()에 대한 것입니다. 사용해.

2. ==============================

   2.여기 어윈 언급 배열 다중 집합을 사용하여 길이를 다른 배열에 대한 안전 또 다른 방법입니다 :

   여기 어윈 언급 배열 다중 집합을 사용하여 길이를 다른 배열에 대한 안전 또 다른 방법입니다 :

   CREATE OR REPLACE FUNCTION zip(array1 anyarray, array2 anyarray) RETURNS text[]
   AS $$
   SELECT array_agg_mult(ARRAY[ARRAY[array1[i],array2[i]]])
   FROM generate_subscripts(
     CASE WHEN array_length(array1,1) >= array_length(array2,1) THEN array1 ELSE array2 END,
     1
   ) AS subscripts(i)
   $$ LANGUAGE sql;
   
   regress=> SELECT zip('{a,b,c}'::text[],'{d,e,f}'::text[]);
            zip         
   ---------------------
    {{a,d},{b,e},{c,f}}
   (1 row)
   
   
   regress=> SELECT zip('{a,b,c}'::text[],'{d,e,f,g}'::text[]);
                zip              
   ------------------------------
    {{a,d},{b,e},{c,f},{NULL,g}}
   (1 row)
   
   regress=> SELECT zip('{a,b,c,z}'::text[],'{d,e,f}'::text[]);
                zip              
   ------------------------------
    {{a,d},{b,e},{c,f},{z,NULL}}
   (1 row)
   

   당신은 대신 = <에> = 길이 테스트를 변경, 널 패딩보다는 여분을 잘라하십시오.

   이 함수는 배열이 1이 아닌 다른 진술 요소를 가질 수 다소 기괴한 PostgreSQL의 기능을 처리하지만, 실제로 아무도 실제로 그 기능을 사용하지 않습니다. 제로 인덱스 3 소자 어레이와 예 :

   regress=> SELECT zip('{a,b,c}'::text[], array_fill('z'::text, ARRAY[3], ARRAY[0]));
             zip           
   ------------------------
    {{a,z},{b,z},{c,NULL}}
   (1 row)
   

   어윈의 코드 반면, 심지어 (를 병합하여) 다차원 배열과 같은 배열 작업을 수행하지만, 길이가 다른 배열로 작업을하지 않습니다.

   배열은 등 다차원 배열, 구성 원산지 지수와 너무 유연하고있어, PostgreSQL의에서 비트 특별하다

   9.4에서는 쓰기를 할 수 있습니다 :

   SELECT array_agg_mult(ARRAY[ARRAY[a,b])
   FROM unnest(array1) WITH ORDINALITY as (o,a)
   NATURAL FULL OUTER JOIN
   unnest(array2) WITH ORDINALITY as (o,b);
   

   최적화가 정렬을 수행하기보다는 함께 기능을 검사하고 간다 가입 특히 이는, 많이 좋네요 될 것입니다.

from https://stackoverflow.com/questions/12414750/is-there-something-like-a-zip-function-in-postgresql-that-combines-two-arrays by cc-by-sa and MIT license