ListAgg (Oracle)에서 중복 제거


44

Oracle 11.2 이전에는 열을 행으로 연결하기 위해 사용자 지정 집계 함수를 사용했습니다. 11.2 LISTAGG기능을 추가 했기 때문에 대신 사용하려고합니다. 내 문제는 결과에서 중복을 제거해야하지만 그렇게 할 수없는 것입니다.

다음은 예입니다.

CREATE TABLE ListAggTest AS (
  SELECT rownum Num1, DECODE(rownum,1,'2',to_char(rownum)) Num2 FROM dual 
     CONNECT BY rownum<=6
  );
SELECT * FROM ListAggTest;
      NUM1 NUM2
---------- ---------------------
         1 2
         2 2                    << Duplicate 2
         3 3
         4 4
         5 5
         6 6

내가보고 싶은 것은 이것입니다 :

      NUM1 NUM2S
---------- --------------------
         1 2-3-4-5-6
         2 2-3-4-5-6
         3 2-3-4-5-6
         4 2-3-4-5-6
         5 2-3-4-5-6
         6 2-3-4-5-6

여기입니다 listagg가까운 버전,하지만 중복을 제거하지 않습니다.

SELECT Num1, listagg(Num2,'-') WITHIN GROUP (ORDER BY NULL) OVER () Num2s 
FROM ListAggTest;

해결책이 있지만 사용자 정의 집계 함수를 계속 사용하는 것보다 나쁩니다.


해야 order by nullorder by Num2또는 I 혼란는 무엇입니까?
Jack Douglas

@Jack-중복 제거와 아무런 차이가 없습니다. 사용에 따라 바람직 할 수 있습니다.
레이 리펠

한숨이 LISTAGG 계속해서 Tom Kyte 'sSTRAGGSTRAGG(DISTINCT ...)
미치지 못합니다.

마지막으로 가능합니다 : LISTAGG DISTINCT
lad2025

답변:


32

regexp_replace다음과 listagg같이 연결 한 후 정규 표현식을 사용 하고 중복을 제거 할 수 있습니다 .

SELECT Num1, 
       RTRIM(
         REGEXP_REPLACE(
           (listagg(Num2,'-') WITHIN GROUP (ORDER BY Num2) OVER ()), 
           '([^-]*)(-\1)+($|-)', 
           '\1\3'),
         '-') Num2s 
FROM ListAggTest;

Oracle의 정규식 플레이버가 lookahead 또는 non-capturing 그룹을 지원하면 더 깔끔 할 수 있지만 그렇지 않습니다 .

그러나이 솔루션은 소스를 두 번 이상 스캔하지 않습니다.

여기 DBFiddle


이 REGEX_REPLACE 기술이 중복을 제거하기 위해 작동하려면 집계 된 문자열에서 중복 값이 ​​서로 나란히 있어야합니다.
Baodad

2
그것이 ORDER BY Num2달성 한 것이 아닙니다 ( 여기 참조 ). 아니면 ORDER BY가 작동해야한다고 지적하고 있습니까?
잭 더글러스

13

내가 볼 수있는 한, 현재 사용 가능한 언어 사양을 사용 하면 으로 수행 해야하는 경우 원하는 것을 달성하는 것이 가장 짧 습니다 listagg.

select distinct
       a.Num1, 
       b.num2s
  from listaggtest a cross join (
       select listagg(num2d, '-') within group (order by num2d) num2s 
       from (
         select distinct Num2 num2d from listaggtest
       )
      ) b;

사용자 지정 집계 솔루션 보다 나쁜 솔루션은 무엇입니까 ?


이것은 작동하지만 두 번의 전체 테이블 스캔을 수행해야합니다.
레이 리펠

작은 테이블이있는 경우 (100000 개 미만의 행) 집계해야하는 성능은 단순한 검색에 허용되는 수준 이상입니다. 이것은 가능한 모든 방법을 거의 1 시간 동안 테스트 한 후에 제가 선택한 솔루션이었습니다!
Mathieu Dumoulin

이것은 중복이 4000자를 초과하는 중간 값을 넣을 때도 작동합니다. regexp솔루션 보다 안전 합니다.
Gordon Linoff

8

이를 위해 사용자 정의 집계 함수 를 작성하십시오 .

Oracle 데이터베이스는 일련의 레코드에서 작업을 수행하기 위해 MAX, MIN, SUM과 같은 미리 정의 된 여러 집계 함수를 제공합니다. 이 사전 정의 된 집계 함수는 스칼라 데이터에만 사용할 수 있습니다. 그러나 객체 유형, 불투명 한 유형 및 LOB를 사용하여 저장된 멀티미디어 데이터와 같이 복잡한 데이터와 함께 사용하기 위해 이러한 함수에 대한 사용자 정의 구현을 작성하거나 완전히 새로운 집계 함수를 정의 할 수 있습니다.

사용자 정의 집계 함수는 Oracle 데이터베이스 내장 집계와 마찬가지로 SQL DML 문에서 사용됩니다. 이러한 기능이 서버에 등록되면 데이터베이스는 기본 기능 대신 제공 한 집계 루틴을 호출합니다.

사용자 정의 집계는 스칼라 데이터와 함께 사용할 수도 있습니다. 예를 들어, 재무 또는 과학 응용과 관련된 복잡한 통계 데이터로 작업하기위한 특수 집계 함수를 구현하는 것이 좋습니다.

사용자 정의 집계는 확장 성 프레임 워크의 기능입니다. ODCIAggregate 인터페이스 루틴을 사용하여이를 구현합니다.


8

이것은 대답이 허용되는 오래된 게시물이지만 LAG () 분석 함수는이 경우 잘 작동하며 주목할만한 것으로 생각합니다.

  • LAG ()는 최소한의 비용으로 num2 열의 중복 값을 제거합니다.
  • 결과를 필터링하기 위해 사소한 정규 표현식이 필요하지 않습니다.
  • 하나의 전체 테이블 스캔 (단순 예제 테이블에서 비용 = 4)

제안 된 코드는 다음과 같습니다.

with nums as (
SELECT 
    num1, 
    num2, 
    decode( lag(num2) over (partition by null order by num2), --get last num2, if any
            --if last num2 is same as this num2, then make it null
            num2, null, 
            num2) newnum2
  FROM ListAggTest
) 
select 
  num1, 
  --listagg ignores NULL values, so duplicates are ignored
  listagg( newnum2,'-') WITHIN GROUP (ORDER BY Num2) OVER () num2s
  from nums;

아래 결과는 OP가 원하는 것으로 보입니다.

NUM1  NUM2S       
1   2-3-4-5-6
2   2-3-4-5-6
3   2-3-4-5-6
4   2-3-4-5-6
5   2-3-4-5-6
6   2-3-4-5-6 

7

내 의견으로는 이미 존재하는 사용자 정의 집계 함수를 사용하는 것만 큼 좋지 않은 문제에 대한 나의 해결책이 있습니다.

SELECT Num1, listagg(Num2,'-') WITHIN GROUP (ORDER BY NULL) OVER () Num2s FROM (
  SELECT Num1, DECODE(ROW_NUMBER() OVER (PARTITION BY Num2 ORDER BY NULL),
     1,Num2,NULL) Num2 FROM ListAggTest
);

5

대신 WMSYS.WM_Concat을 사용하십시오.

SELECT Num1, Replace(Wm_Concat(DISTINCT Num2) OVER (), ',', '-')
FROM ListAggTest;

참고 :이 기능은 문서화되지 않았으며 지원되지 않습니다. 보다https://forums.oracle.com/forums/message.jspa?messageID=4372641#4372641을 하십시오 .


6
오라클 고객 지원 센터에 전화를해서 사용 wm_concat하고 있다면 ( wm_concat문제 자체가 문제의 원인이 아니라고 주장하더라도 ) 문서화되지 않고 지원되지 않기 때문에 도움을 거부 할 근거가 있습니다. 지원되는 기능.
Jack Douglas

5

collect 문을 사용한 다음 컬렉션을 문자열로 변환하는 사용자 지정 pl / sql 함수를 작성할 수도 있습니다.

CREATE TYPE varchar2_ntt AS TABLE OF VARCHAR2(4000);
CREATE TYPE varchar2_ntt AS TABLE OF VARCHAR2(4000);

select cast(collect(distinct num2 order by num2) as varchar2_ntt) 
from listaggtest

당신은 사용할 수 있습니다 distinctorder byA의 collect조항하지만 결합 된 경우 distinct11.2.0.2의로하지 된 작업이 :(

해결 방법은 하위 선택이 될 수 있습니다.

select collect(num2 order by num2) 
from 
( 
    select distinct num2 
    from listaggtest
)

커스텀 pl / sql 함수가 커스텀 집계 함수보다 나은지 알 수 없습니다. 결과 SQL은 후자에 대해 훨씬 간단합니다. 이 문제는 11.2.0.2에 있었으므로 subselect는 피하려고하는 추가 스캔을 추가합니다.
레이 리펠

컬렉션을 문자열로 변환하는 ONCE라는 PL / SQL 함수가 수천 번 호출 된 집계 함수보다 낫다고 말하고 싶습니다. 나는 이것이 문맥 전환을 많이 줄일 것이라고 생각합니다.
니코

당신의 이론은 좋게 들리고 사용자 정의 집계 함수를 피하려고 시도하고 LISTAGG와 같은 내장 집계 함수를 선호하는 한 가지 이유였습니다. 타이밍 비교를하고 싶다면 결과에 관심이 있습니다.
레이 리펠

2

ListAgg를 만나기 전에이 솔루션을 만들었지만이 중복 값 문제와 같은 경우가 여전히 있지만이 도구가 유용합니다. 아래 버전에는 4 가지 인수가있어 결과를 제어 할 수 있습니다.

CLOBlist는 구성자 CLOBlistParam을 매개 변수로 사용합니다. CLOBlistParam에는 4 개의 인수가 있습니다

string VARCHAR2(4000) - The variable to be aggregated
delimiter VARCHAR2(100) - The delimiting string
initiator VARCHAR2(100) - An initial string added before the first value only.
no_dup VARCHAR2(1) - A flag. Duplicates are suppressed if this is Y

사용법 예

--vertical list of comma separated values, no duplicates.
SELECT CLOBlist(CLOBlistParam(column_name,chr(10)||',','','Y')) FROM user_tab_columns
--simple csv
SELECT CLOBlist(CLOBlistParam(table_name,',','','N')) FROM user_tables

요점 링크는 다음과 같습니다.

https://gist.github.com/peter-genesys/d203bfb3d88d5a5664a86ea6ee34eeca] 1


-- Program  : CLOBlist 
-- Name     : CLOB list 
-- Author   : Peter Burgess
-- Purpose  : CLOB list aggregation function for SQL
-- RETURNS CLOB - to allow for more than 4000 chars to be returned by SQL
-- NEW type CLOBlistParam  - allows for definition of the delimiter, and initiator of sequence
------------------------------------------------------------------
--This is an aggregating function for use in SQL.
--It takes the argument and creates a comma delimited list of each instance.

WHENEVER SQLERROR CONTINUE
DROP TYPE CLOBlistImpl;
WHENEVER SQLERROR EXIT FAILURE ROLLBACK

create or replace type CLOBlistParam as object(
  string    VARCHAR2(4000)
 ,delimiter VARCHAR2(100)  
 ,initiator VARCHAR2(100)  
 ,no_dup    VARCHAR2(1)    )
/
show error

--Creating CLOBlist()
--Implement the type CLOBlistImpl to contain the ODCIAggregate routines.
create or replace type CLOBlistImpl as object
(
  g_list CLOB, -- progressive concatenation
  static function ODCIAggregateInitialize(sctx IN OUT CLOBlistImpl)
    return number,
  member function ODCIAggregateIterate(self  IN OUT CLOBlistImpl
                                     , value IN     CLOBlistParam) return number,
  member function ODCIAggregateTerminate(self        IN  CLOBlistImpl
                                       , returnValue OUT CLOB
                                       , flags       IN  number) return number,
  member function ODCIAggregateMerge(self IN OUT CLOBlistImpl
                                   , ctx2 IN     CLOBlistImpl) return number
)
/
show error


--Implement the type body for CLOBlistImpl.
create or replace type body CLOBlistImpl is
static function ODCIAggregateInitialize(sctx IN OUT CLOBlistImpl)
return number is
begin

  sctx := CLOBlistImpl(TO_CHAR(NULL));
  return ODCIConst.Success;
end;

member function ODCIAggregateIterate(self  IN OUT CLOBlistImpl
                                   , value IN     CLOBlistParam) return number is
begin

   IF self.g_list IS NULL THEN
     self.g_list := value.initiator||value.string;
   ELSIF value.no_dup = 'Y' AND
         value.delimiter||self.g_list||value.delimiter LIKE '%'||value.delimiter||value.string||value.delimiter||'%' 
         THEN
     --Do not include duplicate value    
     NULL;
  ELSE
     self.g_list := self.g_list||value.delimiter||value.string;
   END IF;

  return ODCIConst.Success;
end;

member function ODCIAggregateTerminate(self        IN  CLOBlistImpl
                                     , returnValue OUT CLOB
                                     , flags       IN  number) return number is
begin
  returnValue := self.g_list;
  return ODCIConst.Success;
end;

member function ODCIAggregateMerge(self IN OUT CLOBlistImpl
                                 , ctx2 IN     CLOBlistImpl) return number is
begin

  self.g_list := LTRIM( self.g_list||','||ctx2.g_list,',');

  return ODCIConst.Success;
end;
end;
/
show error

--Using CLOBlist() to create a vertical list of comma separated values

--  SELECT CLOBlist(CLOBlistParam(product_code,chr(10)||',','','Y'))
--  FROM   account


--DROP FUNCTION CLOBlist
--/

PROMPT Create the user-defined aggregate.
CREATE OR REPLACE FUNCTION CLOBlist (input CLOBlistParam) RETURN CLOB
PARALLEL_ENABLE AGGREGATE USING CLOBlistImpl;
/
show error

1

원래 게시 후 언젠가는 알고 있지만 이것이 동일한 문제에 대한 답변으로 인터넷 검색 후 찾은 첫 번째 장소 였고 여기에 방문한 다른 사람이 지나치게 복잡한 쿼리에 의존하지 않는 간결한 답변을 찾는 것이 행복 할 것이라고 생각했습니다. 또는 정규식.

원하는 결과를 얻을 수 있습니다.

with nums as (
  select distinct num2 distinct_nums
  from listaggtest
  order by num2
) select num1,
         (select listagg(distinct_nums, '-') within group (order by 1) from nums) nums2list 
         from listaggtest;

1

내 생각은 다음과 같은 저장 함수를 구현하는 것입니다.

CREATE TYPE LISTAGG_DISTINCT_PARAMS AS OBJECT (ELEMENTO VARCHAR2(2000), SEPARATORE VARCHAR2(10));

CREATE TYPE T_LISTA_ELEMENTI AS TABLE OF VARCHAR2(2000);

CREATE TYPE T_LISTAGG_DISTINCT AS OBJECT (

    LISTA_ELEMENTI T_LISTA_ELEMENTI,
        SEPARATORE VARCHAR2(10),

    STATIC FUNCTION ODCIAGGREGATEINITIALIZE(SCTX  IN OUT            T_LISTAGG_DISTINCT) 
                    RETURN NUMBER,

    MEMBER FUNCTION ODCIAGGREGATEITERATE   (SELF  IN OUT            T_LISTAGG_DISTINCT, 
                                            VALUE IN                    LISTAGG_DISTINCT_PARAMS ) 
                    RETURN NUMBER,

    MEMBER FUNCTION ODCIAGGREGATETERMINATE (SELF         IN     T_LISTAGG_DISTINCT,
                                            RETURN_VALUE OUT    VARCHAR2, 
                                            FLAGS        IN     NUMBER      )
                    RETURN NUMBER,

    MEMBER FUNCTION ODCIAGGREGATEMERGE       (SELF               IN OUT T_LISTAGG_DISTINCT,
                                                                                        CTX2                 IN         T_LISTAGG_DISTINCT    )
                    RETURN NUMBER
);

CREATE OR REPLACE TYPE BODY T_LISTAGG_DISTINCT IS 

    STATIC FUNCTION ODCIAGGREGATEINITIALIZE(SCTX IN OUT T_LISTAGG_DISTINCT) RETURN NUMBER IS 
    BEGIN
                SCTX := T_LISTAGG_DISTINCT(T_LISTA_ELEMENTI() , ',');
        RETURN ODCICONST.SUCCESS;
    END;

    MEMBER FUNCTION ODCIAGGREGATEITERATE(SELF IN OUT T_LISTAGG_DISTINCT, VALUE IN LISTAGG_DISTINCT_PARAMS) RETURN NUMBER IS
    BEGIN

                IF VALUE.ELEMENTO IS NOT NULL THEN
                        SELF.LISTA_ELEMENTI.EXTEND;
                        SELF.LISTA_ELEMENTI(SELF.LISTA_ELEMENTI.LAST) := TO_CHAR(VALUE.ELEMENTO);
                        SELF.LISTA_ELEMENTI:= SELF.LISTA_ELEMENTI MULTISET UNION DISTINCT SELF.LISTA_ELEMENTI;
                        SELF.SEPARATORE := VALUE.SEPARATORE;
                END IF;
        RETURN ODCICONST.SUCCESS;
    END;

    MEMBER FUNCTION ODCIAGGREGATETERMINATE(SELF IN T_LISTAGG_DISTINCT, RETURN_VALUE OUT VARCHAR2, FLAGS IN NUMBER) RETURN NUMBER IS
      STRINGA_OUTPUT            CLOB:='';
            LISTA_OUTPUT                T_LISTA_ELEMENTI;
            TERMINATORE                 VARCHAR2(3):='...';
            LUNGHEZZA_MAX           NUMBER:=4000;
    BEGIN

                IF SELF.LISTA_ELEMENTI.EXISTS(1) THEN -- se esiste almeno un elemento nella lista

                        -- inizializza una nuova lista di appoggio
                        LISTA_OUTPUT := T_LISTA_ELEMENTI();

                        -- riversamento dei soli elementi in DISTINCT
                        LISTA_OUTPUT := SELF.LISTA_ELEMENTI MULTISET UNION DISTINCT SELF.LISTA_ELEMENTI;

                        -- ordinamento degli elementi
                        SELECT CAST(MULTISET(SELECT * FROM TABLE(LISTA_OUTPUT) ORDER BY 1 ) AS T_LISTA_ELEMENTI ) INTO LISTA_OUTPUT FROM DUAL;

                        -- concatenazione in una stringa                        
                        FOR I IN LISTA_OUTPUT.FIRST .. LISTA_OUTPUT.LAST - 1
                        LOOP
                            STRINGA_OUTPUT := STRINGA_OUTPUT || LISTA_OUTPUT(I) || SELF.SEPARATORE;
                        END LOOP;
                        STRINGA_OUTPUT := STRINGA_OUTPUT || LISTA_OUTPUT(LISTA_OUTPUT.LAST);

                        -- se la stringa supera la dimensione massima impostata, tronca e termina con un terminatore
                        IF LENGTH(STRINGA_OUTPUT) > LUNGHEZZA_MAX THEN
                                    RETURN_VALUE := SUBSTR(STRINGA_OUTPUT, 0, LUNGHEZZA_MAX - LENGTH(TERMINATORE)) || TERMINATORE;
                        ELSE
                                    RETURN_VALUE:=STRINGA_OUTPUT;
                        END IF;

                ELSE -- se non esiste nessun elemento, restituisci NULL

                        RETURN_VALUE := NULL;

                END IF;

        RETURN ODCICONST.SUCCESS;
    END;

    MEMBER FUNCTION ODCIAGGREGATEMERGE(SELF IN OUT T_LISTAGG_DISTINCT, CTX2 IN T_LISTAGG_DISTINCT) RETURN NUMBER IS
    BEGIN
        RETURN ODCICONST.SUCCESS;
    END;

END; -- fine corpo

CREATE
FUNCTION LISTAGG_DISTINCT (INPUT LISTAGG_DISTINCT_PARAMS) RETURN VARCHAR2
    PARALLEL_ENABLE AGGREGATE USING T_LISTAGG_DISTINCT;

// Example
SELECT LISTAGG_DISTINCT(LISTAGG_DISTINCT_PARAMS(OWNER, ', ')) AS LISTA_OWNER
FROM SYS.ALL_OBJECTS;

미안하지만 어떤 경우에는 (매우 큰 집합의 경우) 오라클은이 오류를 반환 할 수 있습니다.

Object or Collection value was too large. The size of the value
might have exceeded 30k in a SORT context, or the size might be
too big for available memory.

그러나 이것이 좋은 출발점이라고 생각합니다.)


OP에는 LISTAGG이미 자체 사용자 정의 기능이 있습니다. 그들은 LISTAGG버전 11.2부터 사용 가능한 내장 함수를 사용하여이를 수행하는 효율적인 방법을 찾을 수 있는지 명시 적으로 확인하려고했습니다 .
RDFozz

0

이거 한번 해봐:

select num1,listagg(Num2,'-') WITHIN GROUP (ORDER BY NULL) Num2s 
from (
select distinct num1
    ,b.num2
from listaggtest a
    ,(
        select num2
        from listaggtest
    ) b
    order by 1,2
    )
group by num1

다른 가능한 솔루션의 문제는 열 1과 열 2의 결과간에 상관 관계가 없다는 것입니다.이 문제를 해결하기 위해 내부 쿼리는이 상관 관계를 생성 한 다음 해당 결과 집합에서 중복을 제거합니다. listagg를 수행하면 결과 집합이 이미 깨끗합니다. 문제는 사용 가능한 형식으로 데이터를 가져 오는 것과 더 관련이 있습니다.


1
작동 방식에 대한 설명을 추가 할 수 있습니다.
jkavalik

답변 주셔서 감사합니다 그리고 사이트에 오신 것을 환영합니다. 이것이 왜 효과가 있고 어떻게 도움이 될지를 설명 할 수 있다면 더 도움이 될 것입니다.
Tom V

답변을 업데이트하려고했지만 오류가 계속 발생합니다. --- 다른 가능한 솔루션의 문제는 열 1과 열 2의 결과간에 상관 관계가 없다는 것입니다.이 문제를 해결하기 위해 내부 쿼리는이 상관 관계를 생성 한 다음 해당 결과 집합에서 중복을 제거합니다. listagg를 수행하면 결과 집합이 이미 깨끗합니다. 문제는 사용 가능한 형식으로 데이터를 가져 오는 것과 더 관련이 있습니다.
Kevin

-2

SQL은 영어와 매우 유사한 간단한 언어로 설계되었습니다. 영어로 쓰지 않겠습니까?

  1. num2에서 중복을 제거하고 listagg를 집계 함수로 사용-분석이 아닌 문자열의 concat 계산
  2. 하나의 입력에 대해 하나의 결과 행을 원하므로 원본에 결합하십시오.

select num1, num2s
  from (select num2,
               listagg(num2, '-') within group(order by num2) over() num2s
          from listaggtest
         group by num2
       )
  join listaggtest using (num2);


당신의 응답을 주셔서 감사합니다. 이 솔루션에는 두 개의 전체 테이블 스캔이 필요하지만 더 중요한 것은 올바른 결과를 리턴하지 않습니다.
레이 리펠

죄송합니다. 이전 버전과 잘못된 버전을 붙여 넣었습니다.
Štefan

-2
SELECT Num1, listagg(Num2,'-') WITHIN GROUP
(ORDER BY num1) OVER () Num2s FROM 
(select distinct num1 from listAggTest) a,
(select distinct num2 from ListAggTest) b
where num1=num2(+);

주어진 데이터에 대한 올바른 결과를 반환하지만 잘못된 가정이 있습니다. Num1과 Num2는 관련이 없습니다. Num1은 값 a, e, i, o, u, y를 포함하는 Char1 일 수도 있습니다. 무책임한,이 솔루션은 집계 함수 사용의 전체 목적을 무너 뜨리는 두 개의 전체 테이블 스캔이 필요합니다. 솔루션에서 두 번의 테이블 스캔을 허용 한 경우이 방법이 선호됩니다 (샘플 데이터의 경우 다른 것보다 비용이 저렴함). SELECT Num1, ( SELECT LISTAGG(Num2) WITHIN GROUP (ORDER BY Num2) FROM (SELECT distinct Num2 FROM listAggTest) ) Num2 FROM ListAggTest;
레이 리펠

-2

DISTINCT 및 정규식이 지옥처럼 느리기 때문에 가장 효과적인 솔루션은 GROUP BY를 사용한 내부 SELECT입니다.

SELECT num1, LISTAGG(num2, '-') WITHIN GROUP (ORDER BY num2) AS num2s
    FROM (SELECT num1, num2
              FROM ListAggTest
              GROUP BY num1, num2)
    GROUP BY num1;

이 솔루션은 매우 간단합니다. 먼저 num1과 num2의 모든 고유 조합 (내부 SELECT)을 얻은 다음 num1로 그룹화 된 모든 num2의 문자열을 얻습니다.


이 쿼리는 요청 된 결과를 반환하지 않습니다. 와 동일한 결과를 반환합니다 SELECT * FROM ListAggTest;.
Leigh Riffel

자신의 변호에, 그는 아마이 솔루션은 중복 표시 다른 유래 문제에서이 솔루션을 지적했다 않습니다 수정. 그것이 제가 원했던 해결책입니다. 내 테이크를 게시하기 위해 다른 가정을 해야하는 것처럼 보이 므로이 의견을이 질문과 함께 남겨 두겠습니다.
제라드 ONeill
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.