Best way to select match on collection of values

Question

Suppose two tables that are related by a third:
TABLE_ONE
     one_id NUMBER
TABLE_TWO
     two_id NUMBER
TABLE_THREE
     one_id
     two_id
one_id and two_id are primary keys in their respective tables
all combinations of one_id and two_id in TABLE_THREE are guaranteed to be unique, so there will be either zero or one set of records correlating some exact collection of one_id values with the same two_id.
suppose TABLE_ONE has records with the following values for one_id:
1,3,5,7
suppose TABLE_TWO has records with the following values for two_id:
2,4,6
suppose TABLE_THREE has records with the following pairs of values for one_id,two_id:
1,2
3,2
3,4
5,4
1,6
3,6
5,6
7,6
finally, suppose I need to find the value of two_id (if there is one) that EXACTLY correlates with exactly two values of one_id: 3 and 5.
select two_id
from table_three
where one_id in (3,5)
group by two_id
won't work:
* it matches 2, because a match with only the 3,2 record is enough to satisfy the condition
* it matches 4 because it should, but...
* it also matches 6, even though 6 has more records.
in other words, I need a stronger condition than "in" that requires the collection of records in each two_id group match the specified collection EXACTLY (but ideally, in an order-agnostic way, so a match for 3 and 5 would be the same as a match for 5 and 3).
to give a fictional, but illustrative example...
select two_id
from table_three
where one_id IS (3,5)
group by two_id

Answer 1

First a little set up
SQL> SELECT two_id FROM table_three where one_id = 3;
    TWO_ID
         3
     13545
SQL> INSERT INTO table_three VALUES(5,13545);
1 row created.
SQL> commit;
Commit complete.
SQL> SELECT COUNT(*) FROM table_three;
  COUNT(*)
    108376
SQL> SELECT COUNT(*) FROM (SELECT DISTINCT one_id, two_id FROM table_three);
  COUNT(*)
    108376Now, I have 108,376 distinct rows, and only two_id 13545 has both 3 and 5 in one_id.
Andrew's version, which can be simplified (Andrew: You're not ususally so vebose :-) )
SQL> SELECT two_id
  2  FROM table_three
  3  WHERE one_id IN (3,5)
  4  GROUP BY two_id
  5  HAVING COUNT(*) = 2;
Statistics
          0  recursive calls
          0  db block gets
        113  consistent gets
          0  physical reads
          0  redo size
        491  bytes sent via SQL*Net to client
        651  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          1  rows processedNow, 270432:
SQL> SELECT tt1.two_id
  2  FROM   table_three tt1, table_three tt2
  3  WHERE  tt1.two_id = tt2.two_id AND
  4         tt1.one_id = 3 AND
  5         tt2.one_id = 5 AND
  6         NOT EXISTS (SELECT NULL
  7                     FROM   table_three   tt3
  8                     WHERE  tt3.two_id  = tt1.two_id AND
  9                            tt3.one_id <> tt1.one_id AND
10                            tt3.one_id <> tt2.one_id);
Statistics
          0  recursive calls
          0  db block gets
        242  consistent gets
          0  physical reads
          0  redo size
        274  bytes sent via SQL*Net to client
        456  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          0 rows processed Note 0 rows processed.
Now David's first query:
SQL> SELECT two_id
  2  FROM table_three
  3  GROUP BY two_id
  4  HAVING COUNT(*)    = 2 And
  5         MAX(one_id) = 5 And
  6         MIN(one_id) = 3;
Statistics
          0  recursive calls
          0  db block gets
        113  consistent gets
          0  physical reads
          0  redo size
        274  bytes sent via SQL*Net to client
        456  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          0 rows processedAs efficient as Andrew's, but again, no rows processed.
David's Non-set based method:
SQL> SELECT two_id
  2  FROM table_three t3
  3  WHERE one_id = 3 And
  4        EXISTS (SELECT 1 FROM table_three t3_x
  5                WHERE  t3_x.two_id = t3.two_id And
  6                       t3_x.one_id = 5) And
  7        NOT EXISTS (SELECT 1 FROM table_three t3_x
  8                    WHERE  t3_x.two_id = t3.two_id And
  9                           t3_x.one_id NOT IN (3,5));
Statistics
          0  recursive calls
          0  db block gets
        265  consistent gets
          0  physical reads
          0  redo size
        274  bytes sent via SQL*Net to client
        456  bytes received via SQL*Net from client
          1  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          0 rows processedNow, my alternative:
SQL> SELECT two_id FROM table_three
  2  WHERE one_id = 3
  3  INTERSECT
  4  SELECT two_id FROM table_three
  5  WHERE one_id = 5;
Statistics
          0  recursive calls
          0  db block gets
        226  consistent gets
          0  physical reads
          0  redo size
        491  bytes sent via SQL*Net to client
        651  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          1  rows processedSo, not as efficient as Andrew's, but at least correct. Does an Index help Andrew or me?
SQL> CREATE INDEX t3_one_id ON table_three(one_id);
Index created.Now, Andrew, then me.
SQL> SELECT two_id
  2  FROM table_three
  3  WHERE one_id IN (3,5)
  4  GROUP BY two_id
  5  HAVING COUNT(*) = 2;
Statistics
          0  recursive calls
          0  db block gets
          9  consistent gets
          0  physical reads
          0  redo size
        491  bytes sent via SQL*Net to client
        651  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          1  rows processed
SQL> SELECT two_id FROM table_three
  2  WHERE one_id = 3
  3  INTERSECT
  4  SELECT two_id FROM table_three
  5  WHERE one_id = 5;
Statistics
          0  recursive calls
          0  db block gets
          9  consistent gets
          0  physical reads
          0  redo size
        491  bytes sent via SQL*Net to client
        651  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
          1  rows processedWith an index, equivalent gets, but I still do two sorts.
John