Why optimizer select plan with higher cost?

Question

Why optimizer select plan with higher cost?
SQL with hint:
SELECT /*+ index(ordm ORDA_PK) */
ordm.orders_id h_docid, ordm.customer_nr h_clientid,
ordm.cl_doc_type_code h_doctype,
ordm.cl_doc_status_code cl_doc_status_code,
ordm.cl_external_error_code h_errorcode, ordm.sys_version_id h_version,
ordm.doc_number po_number, ordm.curdate po_curdate,
ordm.cl_currency_code po_curr,
TO_CHAR (ordm.amount, 'FM999999999999990.00') po_amount,
ordm.account_nr po_cust_accnum, ordm.customer_name po_cust_name,
ordd.cl_currency_cust_code po_cust_curr,
TO_CHAR (ordd.cust_rate, 'FM999999999990.0099999999') po_cust_rate,
ordd.cust_confirm po_cust_conf, ordd.ben_name po_ben_name,
ordd.ben_accnum po_ben_accnum,
ordd.cl_external_payment_code po_cust_amk, ordd.ben_info po_ben_info,
ordd.comments po_comments
FROM FINIX_IB.orders_archive ordm, FINIX_IB.orders_archive_fields ordd
WHERE ordm.orders_id = ordd.orders_id (+)
AND ordm.orders_id = NVL (4353, ordm.orders_id)
Execution Plan
0 SELECT STATEMENT Optimizer=ALL_ROWS (Cost=4918 Card=1 Bytes=185)
1 0 NESTED LOOPS (OUTER) (Cost=4918 Card=1 Bytes=185)
2 1 TABLE ACCESS (BY INDEX ROWID) OF 'ORDERS_ARCHIVE' (TABLE) (Cost=4916 Card=1 Bytes=87)
3 2 INDEX (FULL SCAN) OF 'ORDA_PK' (INDEX (UNIQUE)) (Cost=4915 Card=1)
4 1 TABLE ACCESS (BY INDEX ROWID) OF 'ORDERS_ARCHIVE_FIELDS' (TABLE) (Cost=2 Card=1 Bytes=98)
5 4 INDEX (RANGE SCAN) OF 'ORDAF_ORDA_FK' (INDEX) (Cost=1 Card=1)
Statistics
0 recursive calls
0 db block gets
4792 consistent gets
4786 physical reads
0 redo size
1020 bytes sent via SQL*Net to client
237 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1 rows processed
SQL without hint:
Execution Plan
0 SELECT STATEMENT Optimizer=ALL_ROWS (Cost=9675 Card=1 Bytes=185)
1 0 NESTED LOOPS (OUTER) (Cost=9675 Card=1 Bytes=185)
2 1 TABLE ACCESS (FULL) OF 'ORDERS_ARCHIVE' (TABLE) (Cost=9673 Card=1 Bytes=87)
3 1 TABLE ACCESS (BY INDEX ROWID) OF 'ORDERS_ARCHIVE_FIELDS' (TABLE) (Cost=2 Card=1 Bytes=98)
4 3 INDEX (RANGE SCAN) OF 'ORDAF_ORDA_FK' (INDEX) (Cost=1 Card=1)
Statistics
1 recursive calls
0 db block gets
39706 consistent gets
39694 physical reads
0 redo size
1037 bytes sent via SQL*Net to client
237 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1 rows processed

Answer 1

The way you are comparing costs, is not the right way, as Billy already told you. Only for one query, the cost of different access paths can be compared, as can be seen in a 10053 trace.
However, your problem seems to arise from the fact that you use the NVL function in the predicate "ordm.orders_id = NVL (4353, ordm.orders_id)". The NVL function always evaluates both expressions, so it has to do a "ordm.orders_id = 4353" and a "ordm.orders_id = ordm.orders_id". This is why both alternatives will show a full scan on your orders_archive table cq. orda_pk index.
You are probably suppling a bind variable to this statement which in some cases contains a null and in some other cases contains a number. If by any chance you always supply a number, then the solution is easy: drop the NVL function and change the predicate to "ordm.orders_id = :<your bind variable>". If not, then you have combined two queries into one, where both variants each have its own optimal plan, but they have to share their plan due to bind variable peeking.
To solve this, I think you have two options:
1) Make sure your statement is reparsed everytime. If your statement doesn't get executed often, this strategy might work. You might implement this by doing unnecessary dynamic sql.
2) Split your query into two queries where one handles the constant number input and the other handles the null/no input.
Below are some test results I used for research:
SQL> create table orders_archive
  2  as
  3  select l orders_id, lpad('*',100,'*') filler from (select level l from dual connect by level <= 10000)
  4  /
Tabel is aangemaakt.
SQL> create table orders_archive_fields
  2  as
  3  select l field_id, l+500 orders_id, lpad('*',100,'*') filler from (select level l from dual connect by level <= 9000)
  4  /
Tabel is aangemaakt.
SQL> alter table orders_archive add constraint orda_pk primary key (orders_id)
  2  /
Tabel is gewijzigd.
SQL> alter table orders_archive_fields add constraint ordaf_pk primary key (field_id)
  2  /
Tabel is gewijzigd.
SQL> alter table orders_archive_fields add constraint ordaf_orda_fk foreign key (orders_id) references orders_archive(orders_id)
  2  /
Tabel is gewijzigd.
SQL> create index ordaf_orda_fk on orders_archive_fields(orders_id)
  2  /
Index is aangemaakt.
SQL> exec dbms_stats.gather_table_stats(user,'ORDERS_ARCHIVE',cascade=>true)
PL/SQL-procedure is geslaagd.
SQL> exec dbms_stats.gather_table_stats(user,'ORDERS_ARCHIVE_FIELDS',cascade=>true)
PL/SQL-procedure is geslaagd.
SQL> explain plan
  2  for
  3  SELECT /*+ index(ordm ORDA_PK) */
  4  ordm.orders_id h_docid, ordm.filler, ordd.filler
  5  FROM orders_archive ordm, orders_archive_fields ordd
  6  WHERE ordm.orders_id = ordd.orders_id (+)
  7  AND ordm.orders_id = NVL(4353,ordm.orders_id)
  8  /
Uitleg is gegeven.
SQL> select * from table(dbms_xplan.display)
  2  /
PLAN_TABLE_OUTPUT
| Id  | Operation                    |  Name                  | Rows  | Bytes | Cost (%CPU)|
|   0 | SELECT STATEMENT             |                        |     1 |   209 |     8   (0)|
|   1 |  NESTED LOOPS OUTER          |                        |     1 |   209 |     8   (0)|
|   2 |   TABLE ACCESS BY INDEX ROWID| ORDERS_ARCHIVE         |     1 |   104 |     7   (0)|
|*  3 |    INDEX FULL SCAN           | ORDA_PK                |     1 |       |    22   (5)|
|   4 |   TABLE ACCESS BY INDEX ROWID| ORDERS_ARCHIVE_FIELDS  |     1 |   105 |     2  (50)|
|*  5 |    INDEX RANGE SCAN          | ORDAF_ORDA_FK          |     1 |       |            |
Predicate Information (identified by operation id):
   3 - filter("ORDM"."ORDERS_ID"=NVL(4353,"ORDM"."ORDERS_ID"))
   5 - access("ORDM"."ORDERS_ID"="ORDD"."ORDERS_ID"(+))
17 rijen zijn geselecteerd.
SQL> exec dbms_lock.sleep(1)
PL/SQL-procedure is geslaagd.
SQL> explain plan
  2  for
  3  SELECT
  4  ordm.orders_id h_docid, ordm.filler, ordd.filler
  5  FROM orders_archive ordm, orders_archive_fields ordd
  6  WHERE ordm.orders_id = ordd.orders_id (+)
  7  AND ordm.orders_id = NVL(4353,ordm.orders_id)
  8  /
Uitleg is gegeven.
SQL> select * from table(dbms_xplan.display)
  2  /
PLAN_TABLE_OUTPUT
| Id  | Operation                    |  Name                  | Rows  | Bytes | Cost (%CPU)|
|   0 | SELECT STATEMENT             |                        |     1 |   209 |    47   (7)|
|   1 |  NESTED LOOPS OUTER          |                        |     1 |   209 |    47   (7)|
|*  2 |   TABLE ACCESS FULL          | ORDERS_ARCHIVE         |     1 |   104 |    46   (7)|
|   3 |   TABLE ACCESS BY INDEX ROWID| ORDERS_ARCHIVE_FIELDS  |     1 |   105 |     2  (50)|
|*  4 |    INDEX RANGE SCAN          | ORDAF_ORDA_FK          |     1 |       |            |
Predicate Information (identified by operation id):
   2 - filter("ORDM"."ORDERS_ID"=NVL(4353,"ORDM"."ORDERS_ID"))
   4 - access("ORDM"."ORDERS_ID"="ORDD"."ORDERS_ID"(+))
16 rijen zijn geselecteerd.So this shows I reproduced your situation. Because the decode function doesn't evaluate all its arguments, but evaluates the first argument to see which arguments to evaluate, you'll see different behaviour now.
SQL> exec dbms_lock.sleep(1)
PL/SQL-procedure is geslaagd.
SQL> explain plan
  2  for
  3  SELECT
  4  ordm.orders_id h_docid, ordm.filler, ordd.filler
  5  FROM orders_archive ordm, orders_archive_fields ordd
  6  WHERE ordm.orders_id = ordd.orders_id (+)
  7  AND ordm.orders_id = decode(4353,null,ordm.orders_id,4353)
  8  /
Uitleg is gegeven.
SQL> select * from table(dbms_xplan.display)
  2  /
PLAN_TABLE_OUTPUT
| Id  | Operation                    |  Name                  | Rows  | Bytes | Cost (%CPU)|
|   0 | SELECT STATEMENT             |                        |     1 |   209 |     3  (34)|
|   1 |  NESTED LOOPS OUTER          |                        |     1 |   209 |     3  (34)|
|   2 |   TABLE ACCESS BY INDEX ROWID| ORDERS_ARCHIVE         |     1 |   104 |     2  (50)|
|*  3 |    INDEX UNIQUE SCAN         | ORDA_PK                |     1 |       |     2  (50)|
|   4 |   TABLE ACCESS BY INDEX ROWID| ORDERS_ARCHIVE_FIELDS  |     1 |   105 |     2  (50)|
|*  5 |    INDEX RANGE SCAN          | ORDAF_ORDA_FK          |     1 |       |            |
Predicate Information (identified by operation id):
   3 - access("ORDM"."ORDERS_ID"=4353)
   5 - access("ORDM"."ORDERS_ID"="ORDD"."ORDERS_ID"(+))
17 rijen zijn geselecteerd.
SQL> exec dbms_lock.sleep(1)
PL/SQL-procedure is geslaagd.
SQL> explain plan
  2  for
  3  SELECT
  4  ordm.orders_id h_docid, ordm.filler, ordd.filler
  5  FROM orders_archive ordm, orders_archive_fields ordd
  6  WHERE ordm.orders_id = ordd.orders_id (+)
  7  AND ordm.orders_id = decode(null,null,ordm.orders_id,null)
  8  /
Uitleg is gegeven.
SQL> select * from table(dbms_xplan.display)
  2  /
PLAN_TABLE_OUTPUT
| Id  | Operation                    |  Name                  | Rows  | Bytes | Cost (%CPU)|
|   0 | SELECT STATEMENT             |                        |     1 |   209 |    46   (5)|
|   1 |  NESTED LOOPS OUTER          |                        |     1 |   209 |    46   (5)|
|*  2 |   TABLE ACCESS FULL          | ORDERS_ARCHIVE         |     1 |   104 |    45   (5)|
|   3 |   TABLE ACCESS BY INDEX ROWID| ORDERS_ARCHIVE_FIELDS  |     1 |   105 |     2  (50)|
|*  4 |    INDEX RANGE SCAN          | ORDAF_ORDA_FK          |     1 |       |            |
Predicate Information (identified by operation id):
   2 - filter("ORDM"."ORDERS_ID"="ORDM"."ORDERS_ID")
   4 - access("ORDM"."ORDERS_ID"="ORDD"."ORDERS_ID"(+))
16 rijen zijn geselecteerd.So two different plans depending on the input.
Regards,
Rob.