That small change has fixed the SQL statement so that it produces the same output as the other methods.

—

Wow – a lot of different ways to solve this type of problem. Fortunately, SQL is not an abbreviation of “Standardized Query Language” – it would have been much too boring to see 10 solutions that were all identical.

SELECT DISTINCT c1
      FROM(
      SELECT * FROM(
         SELECT t1.*,a1.all_c1_cnt,
                COUNT(DISTINCT t1.c2) OVER (PARTITION BY t1.c1) AS matched_c1_cnt
              FROM(
                   SELECT c1,c2,
                     COUNT(DISTINCT c2) OVER (PARTITION BY c1) AS all_c1_cnt
                        FROM t1 WHERE c1='II') a1
                  RIGHT JOIN t1
                    ON(a1.c2=t1.c2
                       AND a1.c1 != t1.c1))
       WHERE matched_c1_cnt= all_c1_cnt)
         ORDER BY 1;

I modified your SQL statement to show a not equal to as !=

If appears that the following line:

COUNT(DISTINCT a1.c2) OVER (PARTITION BY a1.c1) AS matched_c1_cnt

May need to be changed to replace all a1. entries with t1., as shown below (I receive 99 rows for the value of ‘I’ without this change, and 9 rows with the change):

COUNT(DISTINCT t1.c2) OVER (PARTITION BY t1.c1) AS matched_c1_cnt

That is an interesting approach to solving the problem:

SQL> SELECT distinct c1
  2    FROM(
  3    SELECT * FROM(
  4       SELECT t1.*,a1.all_c1_cnt,
  5              COUNT(DISTINCT t1.c2) OVER (PARTITION BY t1.c1) AS matched_c1_cnt
  6            FROM(
  7                 SELECT c1,c2,
  8                   COUNT(DISTINCT c2) OVER (PARTITION BY c1) AS all_c1_cnt
  9                      FROM t1 WHERE c1='I') a1,
 10                 t1
 11           WHERE a1.c1 != t1.c1
 12             AND a1.c2=t1.c2)
 13      WHERE matched_c1_cnt= all_c1_cnt)
 14        ORDER BY 1;

C1
----------
LVII
LXXI
LXXIII
VI
X
XCIX
XV
XXIX
XXXI

9 rows selected.

AS can be seen by the above output, that worked.

I think that there is a risk if all of the elements in the inner-most inline view are a subset of the elements in the outer inline-view (the inline view with != ). This issue is because the equijoin in the WHERE clause will be applied before the COUNT(DISTINCT t1.c2) is calculated:

SQL> SELECT distinct c1
  2    FROM(
  3    SELECT * FROM(
  4       SELECT t1.*,a1.all_c1_cnt,
  5              COUNT(DISTINCT t1.c2) OVER (PARTITION BY t1.c1) AS matched_c1_cnt
  6            FROM(
  7                 SELECT c1,c2,
  8                   COUNT(DISTINCT c2) OVER (PARTITION BY c1) AS all_c1_cnt
  9                      FROM t1 WHERE c1='II') a1,
 10                 t1
 11           WHERE a1.c1 != t1.c1
 12             AND a1.c2=t1.c2)
 13      WHERE matched_c1_cnt= all_c1_cnt)
 14        ORDER BY 1;

C1
----------
C
I
III
IV
IX
LI
LII
LIV
LIX
LV
LVI
LVII
...
XXXI
XXXIV
XXXIX
XXXV
XXXVI
XXXVIII

84 rows selected.

Any suggestions for improvements to make certain that the one set of elements is not merely a subset of the other set of elements?

Thank you for the link… I was having trouble with the function names until I saw the OTN thread linked in your blog article. I believe that I was thinking of the COLLECT function, but the OTN thread also shows a couple of examples with the MODEL clause. Since I was looking for a SQL only solution, the COLLECT function is probably not enough without the help of PL/SQL:

SELECT
  C1,
  COLLECT(TO_CHAR(C2)) C2_LISTING
FROM
  T1
GROUP BY
  C1;

C1         C2_LISTING
---------- -------------------------------------------------------
C          SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '4', '3', '2')
I          SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '10', '9', '8', '7', '6', '5', '4', '3', '2')
II         SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '4', '3', '2')
III        SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '7', '6', '5', '4', '3', '2')
IV         SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '9', '8', '7', '6', '5', '4', '3', '2')
IX         SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '4', '3', '2')
L          SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '3', '2')
LI         SYSTPwdsOE9IeSjCswL2Sefy38w==('1', '5', '4', '3', '2')
...

SQL> SELECT
  2    C1,
  3    SUBSTR(C2_LISTING,INSTR(C2_LISTING,'==')+2)
  4  FROM
  5    (SELECT
  6      C1,
  7      COLLECT(TO_CHAR(C2)) C2_LISTING
  8    FROM
  9      T1
 10    GROUP BY
 11      C1);
  SUBSTR(C2_LISTING,INSTR(C2_LISTING,'==')+2)
                          *
ERROR at line 3:
ORA-00932: inconsistent datatypes: expected CHAR got -

A search for other information also found:
If we allow PL/SQL, http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:2196162600402 shows the STRAGG and CONCAT_ALL custom PL/SQL routines.

This article also shows several methods: http://www.oracle-base.com/articles/misc/StringAggregationTechniques.php

There is a key difference in the OTN thread: you demonstrated timing the execution of each method to find the fastest solution, rather than just accepting the first solution that accomplishes the specified task. I suspect that it might also be a good idea to determine the impact on the CPU – is a solution that is twice as fast, but uses 8 times as much CPU time a good solution – it might in some environments, but not in others (for instance in a multi-user system where several sessions may try to concurrently execute the same SQL statement).

Creating a comma separated list is essentially string aggregation. Prior to LISTAGG, I’ve seen 6 different ways to do string aggregation. I mentioned them all in this blogpost: http://rwijk.blogspot.com/2008/05/string-aggregation-with-model-clause.html.
Your “old method” is one of them.

Regards,
Rob.

Nice potential performance improvement. The FIRST_VALUE function did not occur to me as a possibility.

—

A lot of creativity in the solutions found in this article. Any other solutions?

Two more possible solutions:
#Start of solution 1: Retrieve the C2 value, its relative position, and the total number of elements:

SELECT
  C1,
  C2,
  ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN,
  COUNT(*) OVER  (PARTITION BY C1) CNT
FROM
  T1;

Copy the above twice into inline views. The first inline view will retrieve the values of interest, the second inline view will retrieve all of the other values. The WHERE clause makes certain that we have matching values and positions, and the HAVING clause makes certain that all elements are accounted for:

SELECT
  V2.C1
FROM
  (SELECT
    C1,
    C2,
    ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN,
    COUNT(*) OVER  (PARTITION BY C1) CNT
  FROM
    T1
  WHERE
    C1 = 'I') V1,
  (SELECT
    C1,
    C2,
    ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN,
    COUNT(*) OVER  (PARTITION BY C1) CNT
  FROM
    T1
  WHERE
    C1 != 'I') V2
WHERE
  V1.C2=V2.C2
  AND V1.RN=V2.RN
  AND V1.CNT=V2.CNT
GROUP BY
  V2.C1
HAVING
  COUNT(*)=MAX(V1.CNT);
 
C1
---------------
XXIX
XCIX
XXXI
LXXIII
VI
XV
X
LXXI
LVII

9 rows selected.

II:

C1
*---------------
XCIII
XXIII
XIII
XCVI
XC
LXXXV
C
LXXVII
VIII
IX
LXXV
LXXVIII
LXX

13 rows selected.

III:

C1
---------------
XLVI
XXVIII
LXVI
XCVIII
XVII
LXXVI
LXXXVII
XLIII
LII
XXX

10 rows selected.

#Start of solution 2, use the *old* method (before LISTAGG was an option) to generate a comma separated list:

SELECT
  C1,
  SUBSTR(SYS_CONNECT_BY_PATH(TO_CHAR(C2),','),2) C2_LISTING
FROM
  (SELECT
    C1,
    C2,
    ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN
  FROM
    T1)
CONNECT BY
  PRIOR RN = RN-1
  AND PRIOR C1 = C1
START WITH
  RN = 1;
 
C1              C2_LISTING
--------------- --------------------
C               1
C               1,2
C               1,2,3
C               1,2,3,4
I               1
I               1,2
I               1,2,3
I               1,2,3,4
I               1,2,3,4,5
I               1,2,3,4,5,6
I               1,2,3,4,5,6,7
I               1,2,3,4,5,6,7,8
I               1,2,3,4,5,6,7,8,9
I               1,2,3,4,5,6,7,8,9,10
...

Use a MAX function to retrieve just the complete list for each of the C1 values:

SELECT
  C1,
  MAX(C2_LISTING) C2_LISTING
FROM
  (SELECT
    C1,
    SUBSTR(SYS_CONNECT_BY_PATH(TO_CHAR(C2),','),2) C2_LISTING
  FROM
    (SELECT
      C1,
      C2,
      ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN
    FROM
      T1)
  CONNECT BY
    PRIOR RN = RN-1
    AND PRIOR C1 = C1
  START WITH
    RN = 1)
GROUP BY
  C1
ORDER BY
  C1;
 
C1              C2_LISTING
--------------- --------------------
C               1,2,3,4
I               1,2,3,4,5,6,7,8,9,10
II              1,2,3,4
III             1,2,3,4,5,6,7
IV              1,2,3,4,5,6,7,8,9
IX              1,2,3,4
L               1,2,3
... 
XXXV            1,2,3,4,5,6,7,8,9
XXXVI           1,2,3,4,5
XXXVII          1,2,3
XXXVIII         1,2,3,4,5,6

100 rows selected.

Create two inline views using the above logic. The first inline view will retrieve the values of interest, the second inline view will retrieve all of the other values. The WHERE clause simply locates those C2_LISTING values that match the values of interest.

SELECT
  V2.C1,
  V2.C2_LISTING
FROM
(SELECT
  C1,
  MAX(C2_LISTING) C2_LISTING
FROM
  (SELECT
    C1,
    SUBSTR(SYS_CONNECT_BY_PATH(TO_CHAR(C2),','),2) C2_LISTING
  FROM
    (SELECT
      C1,
      C2,
      ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN
    FROM
      T1
    WHERE
      C1='I')
  CONNECT BY
    PRIOR RN = RN-1
    AND PRIOR C1 = C1
  START WITH
    RN = 1)
GROUP BY
  C1) V1,
(SELECT
  C1,
  MAX(C2_LISTING) C2_LISTING
FROM
  (SELECT
    C1,
    SUBSTR(SYS_CONNECT_BY_PATH(TO_CHAR(C2),','),2) C2_LISTING
  FROM
    (SELECT
      C1,
      C2,
      ROW_NUMBER() OVER (PARTITION BY C1 ORDER BY C2) RN
    FROM
      T1
    WHERE
      C1 != 'I')
  CONNECT BY
    PRIOR RN = RN-1
    AND PRIOR C1 = C1
  START WITH
    RN = 1)
GROUP BY
  C1) V2
WHERE
  V1.C2_LISTING = V2.C2_LISTING
ORDER BY
  V2.C1;

C1              C2_LISTING
--------------- --------------------
LVII            1,2,3,4,5,6,7,8,9,10
LXXI            1,2,3,4,5,6,7,8,9,10
LXXIII          1,2,3,4,5,6,7,8,9,10
VI              1,2,3,4,5,6,7,8,9,10
X               1,2,3,4,5,6,7,8,9,10
XCIX            1,2,3,4,5,6,7,8,9,10
XV              1,2,3,4,5,6,7,8,9,10
XXIX            1,2,3,4,5,6,7,8,9,10
XXXI            1,2,3,4,5,6,7,8,9,10

9 rows selected.

II:

C1              C2_LISTING
--------------- ----------
C               1,2,3,4
IX              1,2,3,4
LXX             1,2,3,4
LXXV            1,2,3,4
LXXVII          1,2,3,4
LXXVIII         1,2,3,4
LXXXV           1,2,3,4
VIII            1,2,3,4
XC              1,2,3,4
XCIII           1,2,3,4
XCVI            1,2,3,4
XIII            1,2,3,4
XXIII           1,2,3,4

III:

C1              C2_LISTING
--------------- -------------
LII             1,2,3,4,5,6,7
LXVI            1,2,3,4,5,6,7
LXXVI           1,2,3,4,5,6,7
LXXXVII         1,2,3,4,5,6,7
XCVIII          1,2,3,4,5,6,7
XLIII           1,2,3,4,5,6,7
XLVI            1,2,3,4,5,6,7
XVII            1,2,3,4,5,6,7
XXVIII           1,2,3,4,5,6,7
XXX             1,2,3,4,5,6,7

10 rows selected.

There must be at least one more solution to this problem without resorting to PL/SQL. Wasn’t there another way to create a comma separated list prior to the introduction of LISTAGG?

My solution would be to use listagg, combined with analytic functions to use only a single table scan, like this:

SQL> exec dbms_stats.gather_table_stats(user,'t1')

PL/SQL procedure successfully completed.

SQL> var your_value varchar2(10)
SQL> exec :your_value := 'I'

PL/SQL procedure successfully completed.

SQL> select *
  2    from t1
  3   where c1 = :your_value
  4  /

C1                      C2
--------------- ----------
I                        1
I                        2
I                        3
I                        4
I                        5
I                        6
I                        7
I                        8

8 rows selected.

SQL> set serveroutput off
SQL> alter session set statistics_level = all
  2  /

Session altered.

SQL> select c1
  2       , c2_listing
  3    from ( select c1
  4                , listagg(to_char(c2), ',') within group (order by c2) c2_listing
  5                , first_value(listagg(to_char(c2), ',') within group (order by c2)) over (order by decode(c1,:your_value,1,2)) x
  6             from t1
  7            group by c1
  8         )
  9   where c2_listing = x
 10  /

C1              C2_LISTING
--------------- --------------------------------------------------
I               1,2,3,4,5,6,7,8
LXXX            1,2,3,4,5,6,7,8
LXXIX           1,2,3,4,5,6,7,8
IV              1,2,3,4,5,6,7,8
XXXVIII         1,2,3,4,5,6,7,8
XXXV            1,2,3,4,5,6,7,8
XLVIII          1,2,3,4,5,6,7,8
XVIII           1,2,3,4,5,6,7,8
XI              1,2,3,4,5,6,7,8

9 rows selected.

SQL> select * from table(dbms_xplan.display_cursor(null,null,'allstats last'))
  2  /

PLAN_TABLE_OUTPUT
---------------------------------------------------------------------------------------------------------------------------------------
SQL_ID  8hhkguv0pcux7, child number 0
-------------------------------------
select c1      , c2_listing   from ( select c1               ,
listagg(to_char(c2), ',') within group (order by c2) c2_listing
      , first_value(listagg(to_char(c2), ',') within group (order by
c2)) over (order by decode(c1,:your_value,1,2)) x            from t1
       group by c1        )  where c2_listing = x

Plan hash value: 913157036

------------------------------------------------------------------------------------------------------------------
| Id  | Operation            | Name | Starts | E-Rows | A-Rows |   A-Time   | Buffers |  OMem |  1Mem | Used-Mem |
------------------------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT     |      |      1 |        |      9 |00:00:00.01 |       3 |       |       |          |
|*  1 |  VIEW                |      |      1 |    100 |      9 |00:00:00.01 |       3 |       |       |          |
|   2 |   WINDOW SORT        |      |      1 |    100 |    100 |00:00:00.01 |       3 | 13312 | 13312 |12288  (0)|
|   3 |    SORT GROUP BY     |      |      1 |    100 |    100 |00:00:00.01 |       3 | 46080 | 46080 |40960  (0)|
|   4 |     TABLE ACCESS FULL| T1   |      1 |    572 |    572 |00:00:00.01 |       3 |       |       |          |
------------------------------------------------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   1 - filter("C2_LISTING"="X")


25 rows selected.

Regards,
Rob.

(10.2.0.5 returns the same message)