Tell oracle which plan is optimal?

Question

It's easy enough in 10g to get a query's history of execution plans and execution statistics, and so it's often easy to tell the bad plan from the good plan especially when user complaints coincide with the plan that uses many more gets per execution. I can see the sql_id, I can see the plan_hash_value for the efficient plan, why can't I just run a function that says "associate this plan with this sql_id always until I tell you otherwise?" Yes, I know there might be more than one optimal plan for some queries, but I have seen plenty of cases where there's one obviously better plan for all inputs - when plan B is used there are no complaints of slowness, when plan C is used users call the help desk. All I need is to get oracle to understand that sql_id A works best with plan B.
Maybe something like:
dbms_stats.create_profile_from_existing_plan(sql_id=> x, plan_hash_value => y );
would get the details from dba_hist*.
This can't be that difficult to implement, can it? Why isn't it provided/supported? How hard would it be to implement using calls to oracle functions?
Thanks.

Answer 1

user447327 wrote:
Thanks, I'm familiar with outlines, in that I don't want to try to record one while trying to get just the right combination of sql text and statistics and inputs to get the plan I want. In this case, the optimizer has already found the good plan, but it doesn't always stick to the good plan. I could change statistics gathering techniquex, but I want a local fix. I'm familiar with the sql tuning advisor, but it never gives me good advice. I can rewrite sql, but not for applications that won't allow me to change the source code.
If I could get that information for a good plan for a particular sql_id/plan_hash_value from v$sql* maybe I could transform a plan into an outline.
So, I'm asking why this apparently simple feature isn't available, not for advice on how to use more complicated existing features. Which is not to say that I don't appreciate your posting that interesting URL. I think maybe I am just lazier ( in a good way, I hope ) than you are.
The answer to my sporadic performance problem is sitting right in front of me. The optimizer has already produced the correct result, along with one or more wrong results. The right answer doesn't need to be recalculated or recosted or reparsed - it's a previously-solved problem. I want Oracle to remember the solution when I tell it that sql_id A and plan_hash_value B should always be together. The information that is already available needs to be addressible in minimal terms ( sql_id, plan_hash_value ) in such a way that the desired plan is always associated with the problem query.
This would be useful in cases where there isn't more than one optimal plan.
dbms_no_cbo.marry(sql_id=> x, plan_hash_value=>y);Apologies, but I saw your post only now. The desperately sought functionality is already there in 10g using Stored Outlines. Note that the CREATE_OUTLINE procedure has been added in 10g, it wasn't available in pre-10g versions.
CREATE_OUTLINE Procedure
This procedure generates an outline from the shared cursor identified by hash value and child number.
DBMS_OUTLN.CREATE_OUTLINE (
   hash_value    IN NUMBER,
   child_number  IN NUMBER,
   category      IN VARCHAR2 DEFAULT 'DEFAULT');Of course, SPM in 11g supersedes this, but this should do what you're looking for in 10g.
Another, slightly more cumbersome approach, would be creating a SQL profile using two undocumented functions/options but it allows to refer to the plans stored in the AWR which is not possible using above approach.
The interesting feature of SQL profiles is that these allow to match SQL similar to the CURSOR_SHARING functionality, i.e. replaces literals with bind variables before attempting to match the SQL text. See the FORCE_MATCH parameter below.
Step 1: Get the outline information from the shared pool or the AWR
Note that the OUTLINE option is undocumented. You could also use the ADVANCED option (undocumented, too, but look here: http://jonathanlewis.wordpress.com/2008/03/06/dbms_xplan3/):
Shared Pool:
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY_CURSOR('<sql_id>', <child_number>, 'OUTLINE');AWR:
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY_AWR('<sql_id>', <child_number>, null, 'OUTLINE');This generates the execution plan along with the OUTLINE information which looks e.g. like that:
  /*+                                                                                               
      BEGIN_OUTLINE_DATA                                                                            
      IGNORE_OPTIM_EMBEDDED_HINTS                                                                   
      OPTIMIZER_FEATURES_ENABLE('10.2.0.3')                                                         
      OPT_PARAM('query_rewrite_enabled' 'false')                                                    
      OUTLINE_LEAF(@"SEL$2")                                                                        
      OUTLINE_LEAF(@"SEL$1")                                                                        
      INDEX(@"SEL$1" "I"@"SEL$1" "I_OBJ#")                                                          
      INDEX_RS_ASC(@"SEL$1" "IST"@"SEL$1" ("IND_STATS$"."OBJ#"))                                    
      NO_ACCESS(@"SEL$1" "C"@"SEL$1")                                                               
      LEADING(@"SEL$1" "I"@"SEL$1" "IST"@"SEL$1" "C"@"SEL$1")                                       
      USE_NL(@"SEL$1" "IST"@"SEL$1")                                                                
      USE_HASH(@"SEL$1" "C"@"SEL$1")                                                                
      INDEX_RS_ASC(@"SEL$2" "CDEF$"@"SEL$2" ("CDEF$"."OBJ#"))                                       
      END_OUTLINE_DATA                                                                              
  */                                                                                                 Step 2:
Generate an SQL profile using above OUTLINE information. Note that the IMPORT_SQL_PROFILE procedure is undocumented.
begin
dbms_sqltune.import_sql_profile(
  sql_text    => '<the_full_sql_text>'
, profile     => sqlprof_attr('<hint1>','<hint2>')
, name        => 'PROFILE_name'
  -- use force_match => true
  -- to use CURSOR_SHARING=SIMILAR
  -- behaviour, i.e. match even with
  -- differing literals
, force_match => false
end;
/A code snippet how this could be combined into an automated SQL*Plus script, parameter is the SQL_ID:
declare
  ar_hint_table    sys.dbms_debug_vc2coll;
  ar_profile_hints sys.sqlprof_attr := sys.sqlprof_attr();
  cl_sql_text      clob;
  i                pls_integer;
begin
  with a as (
  select
           rownum as r_no
         , a.*
  from
           table(
             -- replace with
             -- DBMS_XPLAN.DISPLAY_AWR
             -- if required
             dbms_xplan.display_cursor(
               '&&1'
             ,  null
             , 'OUTLINE'
             -- dbms_xplan.display_awr(
             --   '&&1'
             -- , null
             -- , null
             -- , 'OUTLINE'
           ) a
  b as (
  select
           min(r_no) as start_r_no
  from
           a
  where
           a.plan_table_output = 'Outline Data'
  c as (
  select
           min(r_no) as end_r_no
  from
           a
         , b
  where
           a.r_no > b.start_r_no
  and      a.plan_table_output = '  */'
  d as (
  select
           instr(a.plan_table_output, 'BEGIN_OUTLINE_DATA') as start_col
  from
           a
         , b
  where
           r_no = b.start_r_no + 4
  select
           substr(a.plan_table_output, d.start_col) as outline_hints
  bulk collect
  into
           ar_hint_table
  from
           a
         , b
         , c
         , d
  where
           a.r_no >= b.start_r_no + 4
  and      a.r_no <= c.end_r_no - 1
  order by
           a.r_no;
  select
           sql_text
  into
           cl_sql_text
  from
           -- replace with dba_hist_sqltext
           -- if required for AWR based
           -- execution
           v$sql
           -- sys.dba_hist_sqltext
  where
           sql_id = '&&1';
  -- this is only required
  -- to concatenate hints
  -- splitted across several lines
  -- and could be done in SQL, too
  i := ar_hint_table.first;
  while i is not null
  loop
    if ar_hint_table.exists(i + 1) then
      if substr(ar_hint_table(i + 1), 1, 1) = ' ' then
        ar_hint_table(i) := ar_hint_table(i) || trim(ar_hint_table(i + 1));
        ar_hint_table.delete(i + 1);
      end if;
    end if;
    i := ar_hint_table.next(i);
  end loop;
  i := ar_hint_table.first;
  while i is not null
  loop
    ar_profile_hints.extend;
    ar_profile_hints(ar_profile_hints.count) := ar_hint_table(i);
    i := ar_hint_table.next(i);
  end loop;
  dbms_sqltune.import_sql_profile(
    sql_text    => cl_sql_text
  , profile     => ar_profile_hints
  , name        => 'PROFILE_&&1'
  -- use force_match => true
  -- to use CURSOR_SHARING=SIMILAR
  -- behaviour, i.e. match even with
  -- differing literals
  , force_match => false
end;
/Regards,
Randolf
Oracle related stuff blog:
http://oracle-randolf.blogspot.com/
SQLTools++ for Oracle (Open source Oracle GUI for Windows):
http://www.sqltools-plusplus.org:7676/
http://sourceforge.net/projects/sqlt-pp/
Edited by: Randolf Geist on Mar 26, 2009 10:00 PM
Added automated SQL profile generation