Selecting all columns makes oracle use more indexes than only selectng one?

Question

I have 3 queries here that differ only slightly, conceptually, but the plans are massively different. What I cant work out is that the difference is only in the select list.. The fields referenced in the where clause are properly indexed for this purpose
SELECT
  scc.expiry_date
FROM
  bw3.int_file_log_details  ifld
  INNER JOIN
  bw3.svc_card_status_change scsc
  USING
    (institution_number, file_number)
  INNER JOIN bw3.svc_client_cards scc
  USING
    (card_number)
WHERE
  institution_number = '00000001' AND
  file_number = '00002504'This one above does a full table scan of SCC, over 3.5 million records
SELECT
  card_number
FROM
  bw3.int_file_log_details  ifld
  INNER JOIN
  bw3.svc_card_status_change scsc
  USING
    (institution_number, file_number)
  INNER JOIN bw3.svc_client_cards scc
  USING
    (card_number)
WHERE
  institution_number = '00000001' AND
  file_number = '00002504'This one above does an index fast full scan of SCC's pk (which is cardnumber), as does doing a "SELECT null as dummy FROM..."
SELECT
FROM
  bw3.int_file_log_details  ifld
  INNER JOIN
  bw3.svc_card_status_change scsc
  USING
    (institution_number, file_number)
  INNER JOIN bw3.svc_client_cards scc
  USING
    (card_number)
WHERE
  institution_number = '00000001' AND
  file_number = '00002504'This one above does the index range scan of the columns mentioned in the where clause and two index unique scans to link in IFLD and SCC (because they are joined on their PKs)
I would expect all queries to run this way and completes in ~0.01 seconds
Now, I get that oracle will sometimes use only an index instead of a table access when the requested data can be got from the index, but the actual query is pulling data from some columns not in indexes, so must be accessed in the table:
SELECT
  scsc.card_prod_data as "Field1",
  substr(card_number,1,4)||' '||
    substr(card_number,5,4)||' '||
    substr(card_number,9,4)||' '||
    substr(card_number,13,4)||' '||
    substr(card_number,17) as "Field2",
  '                           ' as "Field3",
  scc.emboss_line_1 as "Field4",
  scc.emboss_line_2 as "Field5",
  TO_CHAR(TO_DATE(scc.last_issued_date, 'YYYYMMDD'), 'MM/YY ')||
    TO_CHAR(TO_DATE(scc.expiry_date, 'YYYYMMDD'), 'MM/YY  ')||
    '    ' as "Field6",
  'B'||
    card_number||
    '^'||
    RPAD('0', 27, ' ')||
    '^'||
    to_char(to_date(scc.expiry_date, 'YYYYMMDD'), 'YYMM')||
    service_category_code||
    '000000000000' as "Field7",
  card_number||
    '='||
    to_char(to_date(scc.expiry_date, 'YYYYMMDD'), 'YYMM')||
    service_category_code||
    '000000000000' as "Field8",
  card_number as "Field9",
  scsc.cvv_cvc2 as "Field10"
FROM
  bw3.int_file_log_details  ifld
  INNER JOIN
  bw3.svc_card_status_change scsc
  USING
    (institution_number, file_number)
  INNER JOIN bw3.svc_client_cards scc
  USING
    (card_number)
WHERE
  institution_number = '00000001' AND
  file_number = '00002504'This query above, which uses some data from all tables, does a table full scan of SCC, yet if I SELECT * FROM.. I get the expected index usage and table access by index rowid for all tables..
Why is oracle doing an FTS when I choose only some columns, yet doing index access when I select * ?
Edited by: charred on Oct 5, 2010 11:37 AM

Answer 1

Selectivity of indexes?
For a query linking these tables:
int_file_log_details <-> svc_card_status_change <-> svc_client_cards
I'm expecting Oracle to:
Use an index range scan of the index on svc_card_status_change that is a nonunique index of institution_number and file number. Selectivity of this index is:
1 institution number in the entire table
59 distinct file numbers in the entire table
4.1million records in the entire table
From there, with the records it found, to use index unique scan of the PKs of int_file_log_details (file_number: 1 record required) and PK of svc_client_cards (card_number: poetntially thousands of records required)
I can understand if oracle might decide it can get 69k records out of 4.1 million faster by FTS the cards table rather than having the indirection of the index... what I cannot understand is:
If I select all the data from the query (SELECT *) it does unique index scans for the 2 records
If I select say, only one non-indexed non-joined column from each table, oracle prefers a FTS of the cards table..
Is oracle not realising that there are only 2 records I need out of cards? Why would select * differ? Is it that oracle thinks "select * is a large amount of data, so it'll be faster to use the index and target certain rows" vs "select one_column can be garnered more quickly by scanning the table and generating a lower overall memory load" ?