Sub selects in a SQL statement

Question

Hi, I have a query with an obsene amount of sub selects,
for example :
SELECT p.ID,
(select something from data where id = p.id) data1,
(select somelse from data2 where id = p.id) data2,
(select someelse from data3 where id = p.id) data3,
(select someelse from data4 where id = p.id) data4,
(select someelse from data5 where id = p.id) data5,
FROM property P
WHERE ..........
this query is taking a long time to process. Is there a more efficient way of doing such a statement?
thanks in advance

Answer 1

Gabe:
Since the original poster said "this query is taking a long time to process", I assumed that there was a one-to-one relationship between properties and each of the dataX tables, otherwise, as you pointed out, he would be complaining about ORA-01427: single-row subquery returns more than one row
In my union, I am returning a single column from each of the data tables (plus the id), and a NULL for each of the other columns in the in-line view. The MAX function just gets the single row for each column that actually has a value.
As a test case, I did:
CREATE TABLE properties AS
SELECT rownum id, object_name
FROM all_objects
WHERE rownum < 11;
CREATE TABLE data1 (id NUMBER, descr VARCHAR2(10));
INSERT INTO data1 VALUES(1, 'ONE');
INSERT INTO data1 VALUES(2, 'TWO');
INSERT INTO data1 VALUES(3, 'THREE');
CREATE TABLE data2 (id NUMBER, descr VARCHAR2(10));
INSERT INTO data2 VALUES(4, 'FOUR');
INSERT INTO data2 VALUES(5, 'FIVE');
INSERT INTO data2 VALUES(6, 'SIX');
CREATE TABLE data3 (id NUMBER, descr VARCHAR2(10));
INSERT INTO data3 VALUES(7, 'SEVEN');
INSERT INTO data3 VALUES(8, 'EIGHT');
INSERT INTO data3 VALUES(9, 'NINE');The original version as posted retrieves:
SQL> SELECT p.id, p.object_name,
  2         (SELECT descr FROM data1 WHERE id = p.id) data1,
  3         (SELECT descr FROM data2 WHERE id = p.id) data2,
  4         (SELECT descr FROM data3 WHERE id = p.id) data3
  5  FROM properties p
  6  ORDER BY p.id;
        ID OBJECT_NAME                    DATA1      DATA2      DATA3
         1 TAB$                           ONE
         2 I_IND1                         TWO
         3 I_COBJ#                        THREE
         4 USER$                                     FOUR
         5 I_OBJ1                                    FIVE
         6 I_PROXY_ROLE_DATA$_2                      SIX
         7 BOOTSTRAP$                                           SEVEN
         8 I_ICOL1                                              EIGHT
         9 UNDO$                                                NINE
        10 PROXY_ROLE_DATA$
10 rows selected.
Statistics
          0  recursive calls
          0  db block gets
         93 consistent gets
          0  physical reads
          0  redo size
       1000  bytes sent via SQL*Net to client
        655  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
         10  rows processedBut, it does a SELECT (hopefully indexed) of data1, data2, and data3 for each row in properties. Minimally, 9 gets per row of properties (index root, index leaf, table row for each of data1, data2, data3) without even getting any data from properties.
My query returns:
SQL> SELECT p.id, p.object_name, a.data1, a.data2, a.data3
  2  FROM properties p,
  3       (SELECT id, MAX(data1) data1, MAX(data2) data2, MAX(data3) data3
  4        FROM (SELECT id, descr data1, TO_CHAR(NULL) data2, TO_CHAR(NULL) data3
  5              FROM data1
  6              UNION ALL
  7              SELECT id, TO_CHAR(NULL), descr, TO_CHAR(NULL)
  8              FROM data2
  9              UNION ALL
10              SELECT id, TO_CHAR(NULL), TO_CHAR(NULL), descr
11              FROM data3)
12        GROUP BY id) a
13  WHERE p.id = a.id(+)
14  ORDER BY p.id;
        ID OBJECT_NAME                    DATA1      DATA2      DATA3
         1 TAB$                           ONE
         2 I_IND1                         TWO
         3 I_COBJ#                        THREE
         4 USER$                                     FOUR
         5 I_OBJ1                                    FIVE
         6 I_PROXY_ROLE_DATA$_2                      SIX
         7 BOOTSTRAP$                                           SEVEN
         8 I_ICOL1                                              EIGHT
         9 UNDO$                                                NINE
        10 PROXY_ROLE_DATA$
10 rows selected.
Statistics
          0  recursive calls
          0  db block gets
         12 consistent gets
          0  physical reads
          0  redo size
       1000  bytes sent via SQL*Net to client
        655  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          2  sorts (memory)
          0  sorts (disk)
         10  rows processedThe same result, but 1/8 of the gets. an outer join is also possible:
SQL> SELECT p.id, p.object_name, d1.descr data1, d2.descr data2, d3.descr data3
  2  FROM properties p, data1 d1, data2 d2, data3 d3
  3  WHERE p.id = d1.id(+) AND
  4        p.id = d2.id(+) AND
  5        p.id = d3.id(+)
  6  ORDER BY p.id;
        ID OBJECT_NAME                    DATA1      DATA2      DATA3
         1 TAB$                           ONE
         2 I_IND1                         TWO
         3 I_COBJ#                        THREE
         4 USER$                                     FOUR
         5 I_OBJ1                                    FIVE
         6 I_PROXY_ROLE_DATA$_2                      SIX
         7 BOOTSTRAP$                                           SEVEN
         8 I_ICOL1                                              EIGHT
         9 UNDO$                                                NINE
        10 PROXY_ROLE_DATA$
10 rows selected.
Statistics
          0  recursive calls
          0  db block gets
         12 consistent gets
          0  physical reads
          0  redo size
       1000  bytes sent via SQL*Net to client
        655  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
         10  rows processedSo, the same number of gets, and it saves one sort. But if the tables are large, multiple outer joins may not be as efficient as one outer join to the union all query.
HTH
John