Kind of loop in sql? Any alternative?

Question

Hi,
We have the following table
create table orders
order_id NUMBER(10),
vehicle_id NUMEBR(10),
customer_id NUMBER(10),
data VARCHAR(10)
order_id, customer_id and vehicle_id are indexed.
In this table are stored multiple orders for multiple vehicles.
I need an sql-statements which returns me the last 5 orders for each truck.
For only one vehicle its no problem:
select * from orders
where vehicle_id = <ID>
and rownum <=5
order by order_id desc;
But I need something like a loop to perform this statement for each vehicle_id.
Or is there any way to put it into a subselect?
Any ideas are welcome ;-)
Thanks in advance,
Andreas

Answer 1

Hello
Effectively by having the bind variable in there you are partitioning by customer and vehicle id, so by adding customer_id into the partition statement, the optimiser should be able to push the bind variable right down to the inner most view...
XXX> CREATE TABLE dt_orders
  2  (      order_id NUMBER NOT NULL,
  3         customer_id     NUMBER NOT NULL,
  4         vehicle_id      NUMBER NOT NULL,
  5         some_padding    VARCHAR2(100) NOT NULL
  6  )
  7  /
Table created.
Elapsed: 00:00:00.23
XXX> INSERT INTO dt_orders SELECT ROWNUM ID, MOD(ROWNUM,100),MOD(ROWNUM,100), lpad(
  2  /
10000 rows created.
Elapsed: 00:00:00.43
XXX> CREATE INDEX dt_orders_i1 ON dt_orders(customer_id)
  2  /
Index created.
Elapsed: 00:00:00.17
XXX> select *
  2  from (
  3  select o.*, rank() over(partition by vehicle_id order by order_id desc) rk
  4  from dt_orders o
  5  where customer_id = :var_cust_id
  6  )
  7  where rk <= 5;
5 rows selected.
Elapsed: 00:00:00.11
Execution Plan
Plan hash value: 3174093828
| Id  | Operation                     | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
|   0 | SELECT STATEMENT              |              |   107 | 11128 |    22   (5)| 00:00:01 |
|*  1 |  VIEW                         |              |   107 | 11128 |    22   (5)| 00:00:01 |
|*  2 |   WINDOW SORT PUSHED RANK     |              |   107 |  9737 |    22   (5)| 00:00:01 |
|   3 |    TABLE ACCESS BY INDEX ROWID| DT_ORDERS    |   107 |  9737 |    21   (0)| 00:00:01 |
|*  4 |     INDEX RANGE SCAN          | DT_ORDERS_I1 |    43 |       |     1   (0)| 00:00:01 |
Predicate Information (identified by operation id):
   1 - filter("RK"<=5)
   2 - filter(RANK() OVER ( PARTITION BY "VEHICLE_ID" ORDER BY
              INTERNAL_FUNCTION("ORDER_ID") DESC )<=5)
   4 - access("CUSTOMER_ID"=TO_NUMBER(:VAR_CUST_ID))  <----
Note
   - dynamic sampling used for this statement
Statistics
         36  recursive calls
          0  db block gets
        247  consistent gets
          2  physical reads
          0  redo size
        518  bytes sent via SQL*Net to client
        239  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          5  rows processedyour original statement showing that the bind variable has been applied to access the dt_orders table via the index (predicate 4)
If I change the statement to put the bind variable outside the inline view, we now do a full scan and you can see from predicate 1 that the customer id is being filtered at the highest level.
XXX> select *
  2  from (
  3  select o.*, rank() over(partition by vehicle_id order by order_id desc) rk
  4  from dt_orders o
  5  )
  6  where rk <= 5
  7  AND customer_id = :var_cust_id ;
5 rows selected.
Elapsed: 00:00:00.32
Execution Plan
Plan hash value: 3560032888
| Id  | Operation                | Name      | Rows  | Bytes |TempSpc| Cost (%CPU)| Time     |
|   0 | SELECT STATEMENT         |           | 10696 |  1086K|       |   268   (2)| 00:00:04 |
|*  1 |  VIEW                    |           | 10696 |  1086K|       |   268   (2)| 00:00:04 |
|*  2 |   WINDOW SORT PUSHED RANK|           | 10696 |   950K|  2216K|   268   (2)| 00:00:04 |
|   3 |    TABLE ACCESS FULL     | DT_ORDERS | 10696 |   950K|       |    39   (3)| 00:00:01 |
Predicate Information (identified by operation id):
   1 - filter("RK"<=5 AND "CUSTOMER_ID"=TO_NUMBER(:VAR_CUST_ID))  <---
   2 - filter(RANK() OVER ( PARTITION BY "VEHICLE_ID" ORDER BY
              INTERNAL_FUNCTION("ORDER_ID") DESC )<=5)
Note
   - dynamic sampling used for this statement
Statistics
          4  recursive calls
          0  db block gets
        240  consistent gets
          0  physical reads
          0  redo size
        519  bytes sent via SQL*Net to client
        239  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          5  rows processedBut those two statements are really the same. By applying the filter inside the view as in your original, it means it's only going to calculate the rank for those customers. So we can add the customer id to the partition by statement which means the optimiser can safely push the predicate back down to the access of the orders table..
XXX> select *
  2  from (
  3  select o.*, rank() over(partition by customer_id,vehicle_id order by order_id desc) rk
  4  from dt_orders o
  5  )
  6  where rk <= 5
  7  AND customer_id = :var_cust_id ;
5 rows selected.
Elapsed: 00:00:00.04
Execution Plan
Plan hash value: 3174093828
| Id  | Operation                     | Name         | Rows  | Bytes | Cost (%CPU)| Time     |
|   0 | SELECT STATEMENT              |              |   107 | 11128 |    22   (5)| 00:00:01 |
|*  1 |  VIEW                         |              |   107 | 11128 |    22   (5)| 00:00:01 |
|*  2 |   WINDOW SORT PUSHED RANK     |              |   107 |  9737 |    22   (5)| 00:00:01 |
|   3 |    TABLE ACCESS BY INDEX ROWID| DT_ORDERS    |   107 |  9737 |    21   (0)| 00:00:01 |
|*  4 |     INDEX RANGE SCAN          | DT_ORDERS_I1 |    43 |       |     1   (0)| 00:00:01 |
Predicate Information (identified by operation id):
   1 - filter("RK"<=5)
   2 - filter(RANK() OVER ( PARTITION BY "CUSTOMER_ID","VEHICLE_ID" ORDER BY
              INTERNAL_FUNCTION("ORDER_ID") DESC )<=5)
   4 - access("O"."CUSTOMER_ID"=TO_NUMBER(:VAR_CUST_ID))  <----
Note
   - dynamic sampling used for this statement
Statistics
          9  recursive calls
          0  db block gets
        244  consistent gets
          0  physical reads
          0  redo size
        519  bytes sent via SQL*Net to client
        239  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          5  rows processedHTH
David