Kerry Osborne's Oracle Blog

One of my favorite holiday treats was my MeeMaw’s fudge brownies. Note: I did a brief poll (only 5 people so not statistically significant) but nevertheless, 100% of the people I surveyed had a grandparent that they called either MeeMaw or PopPa. And 40% had both a MeeMaw and a PopPa. Of course all 5 of the pollees were native Texans. Anyway, here’s what my MeeMaw’s fudge brownies looked like.

Oracle has a long history of baking fudge as well.

So here’s a little Oracle Fudge for you!

11gR1 has 4 parameters with the word fudge in them.

_nested_loop_fudge
_parallelism_cost_fudge_factor
_px_broadcast_fudge_factor
_query_rewrite_fudge

These four “fudge” parameters have been around with the same default values since at least 8.1.7. Maybe the elves will fix these in version 12.

And in keeping with the holiday theme, I’m reminded of the song “My Favorite Things” (often sung at Christmas) that goes:

“blah, blah, blah, blah, blah, blah,
These are a few of my favorite things”
(think Julie Andrews in Sound of Music)

Anyway, here’s a few of my favorite parameters (and my interpretation of what they mean):

db_cache_advice – If you turn this one on, Oracle will tell you what to do with your money.
db_cache_size – And this one will tell you how much money you have.
db_ultra_safe – Oddly enough, this one defaults to OFF. Seems like you’d want your database to be “Ultra Safe”.
ifile – Looks like someone from Apple slipped this one in (you know – iPod, iPhone, iMac, etc…).
large_pool_size – Just how big is your pool?
skip_unusable_indexes – Defaults to TRUE. I guess if you want, you can tell Oracle to use those unusable indexes.
_addm_skiprules – Yeah, rules suck!
_ash_size – Do these pants make my butt look big?
_backup_max_gap_size – How big does the doorway have to be to get your butt through it?
_asm_disk_repair_time – Uh oh, time to repair those disks.
_avoid_prepare – Why get ready ahead of time.
_awr_disabled_flush_tables – Not sure but it sounds stinky.
_awr_sql_child_limit – Population control?
_bloom_pruning_enabled – Trim the roses!
_bwr_for_flushed_pi – Not sure what this one does, but flushing pie seems like such a waste.
_cvw_enable_weak_checking – I’d prefer strong checking please! Get that weak stuff out of here!
_db_aging_cool_count – I used to be cool, I think.
_db_aging_hot_criteria – ???
_db_block_bad_write_check – I hope our database is not writing bad checks!
_db_block_check_for_debug – I think a developer from Chicago named this one (and it should be: _db_block_check_for_the_bug).
_db_cache_crx_check – I don’t know what a crx check is, but cashing any kind of check should be good, right?
_db_large_dirty_queue – Just like in the laundry room at home.
_db_row_overlap_checking – Do your rows overlap? Perhaps we should check that.
_disable_fast_aggregation – Why would anyone use this, “No thanks, I want really slow aggregation”
_dtree_pruning_enabled – Trim D-Tree too while yer at it!
_extended_pruning_enabled – Cut ’em way back!
_disable_recoverable_recovery – Hmmmm???? I guess if you don’t want your recovery to be recoverable you can set this one.
_dummy_instance – I’ve thought this many times (it’s basically the same as the _stupid_database parameter).
_dispatcher_rate_scale – How much are we paying that dispatcher anyway?
_fairness_threshold – My queries should always run faster than everyone else’s, I think that’s fair.
_flashback_fuzzy_barrier – Fuzzy Wuzzy was a bear, Fuzzy Wuzzy had no hair, Fuzzy Wuzzy wasn’t very fuzzy was he.
_gc_defer_time – I’ve wanted to do this many times in the past.
_ges_dd_debug – Sounds like a speech impediment, b,b,but maybe not.
_hard_protection – Well if it was easy, everyone would be doing it.
_imr_avoid_double_voting – They needed this in Florida during the 2004 election.
_in_memory_undo – Same as the _forget parameter.
_kdli_STOP_dba – Keep the DBA from messing up the system.
_kdli_delay_flushes – Don’t flush until a specified threshold is reached.
_kdlwp_flush_threshold – The amount of poo that triggers flushing (see _kdli_delay_flushes).
_kdli_memory_protect – Same as the _dont_forget parameter (i.e. the opposite of the _forget parameter).
_kdli_squeeze – One of my favorite bands.
_kebm_nstrikes – The number of strikes before you are out (defaults to 3 – no joke).
_kebm_suspension_time – How long before convicted felons can return to playing football.
_kill_enqueue_blocker – What the defensive linemen try to do on every play.
_kill_java_threads_on_eoc – I always turn this one on, because anything that kills java threads is OK in my book.
_kfm_disable_set_fence – Good fences make good neighbors.
_kse_signature_limit – The cash advance limit on your credit card.
_kse_snap_ring_size
_ksi_clientlocks_enabled – Can be used on clients when they won’t follow your advice.
_lm_better_ddvictim – Not sure what this one does, but it has the word victim in it, scary!
_lm_master_weight – Set this to get control of your diet.
_lm_tx_delta – Ah the Texas delta, I think it’s some where near Galveston.
_max_exponential_sleep – The older I get, the longer the naps.
_memory_sanity_check – Do I seem crazy to you?
_mv_generalized_oj_refresh_opt – In general, orange juice is refreshing!
_olapi_memory_operation_history_retention – Same as the _dont_forget parameter (see _kdli_memory_protect).
_olap_wrap_errors – When you cut the wrapping paper too short and it won’t go around the present and you have to cut a little strip to cover the gap.
_optimizer_ignore_hints – No matter what you hear in there, no matter how cruelly I beg you, no matter how terribly I may scream, don’t open that door.
_optimizer_random_plan – This one is self evident and has defaulted to TRUE since the CBO first came out.
_optimizer_squ_bottomup – Bottoms Up!
_parallel_fake_class_pct – “The higher you hold your pinky, the fancier you are.” – Patrick from Sponge Bob.
_parallel_syspls_obey_force – The parameter that allows you to get the sysadmins (syspls) to do what you tell them.
_pct_refresh_double_count_prevented – This would have been useful in Florida during the 2004 election.
_pdml_gim_staggered – Gim must have had too much to drink.
_pred_move_around – If your dad was in the air force and you moved from base to base while growing up, setting this parameter will make you feel right at home.
_px_no_stealing – This parameter is set to TRUE by default and it’s actually against the law to change it.
_px_nss_planb – Use this parameter if plan A doesn’t work.
_shrunk_aggs_enabled – I don’t like shrunk aggs, I like the big-uns, wif bacun!
_spin_count – Have you ever seen fans at a baseball game put their heads on the end of a bat and turn circles and then run? You get the idea.
_two_pass_reverse_polish_enabled – I don’t think this one is politically correct.
_use_best_fit – One size fits all does not fit all.
_write_clones – Send a letter to your siblings.
_ultrafast_latch_statistics – Anything that is ultrafast has got to be fantastic!
_xsolapi_densify_cubes – Densify??? I think they made that word up.
_xsolapi_optimize_suppression – Allows us to to keep the common man down as effectively as possible.
_xsolapi_stringify_order_levels – Stringify??? I think they made that word up too!
_xsolapi_use_models – It will make our advertising look better!

Here a few that allow you to turn on (or off) special checks:

_disable_acid_check – My acid is just fine thanks.
_disable_cpu_check – Yep, this machine has got at least one.
_disable_health_check – I don’t need no stinking annual checkup!
_disable_image_check – And I really don’t care how I look!

Here’s a few parameters dealing with death:

_px_execution_services_enabled – Apparently we can set up a special service for executions.
_xsolapi_share_executors – And if you have a lot of killing to do, it’s wasteful to not share executors.
_imr_splitbrain_res_wait – Sounds like it would hurt (if not kill).
_ksv_spawn_control_all – Creates zombies.
_cgs_zombie_member_kill_wait – Specifies how long to wait before slaying zombies!
_imr_evicted_member_kill – Boy I hope I don’t get evicted!
_ksu_diag_kill_time – Killing Time!
_ksuitm_dont_kill_dumper – The rumor is that this one was named by an animal rights activist and it was supposed to be “Don’t Kill Thumper”.
_lm_rcvr_hang_kill – Death by hanging!
_ksv_pool_hang_kill_to – If hanging doesn’t work, drown them in the pool!
_hang_detection – Turn this on so we’ll know when anybody is getting hung.

And just in case the 2000+ parameters in 11g aren’t enough, they have a few spares:

_first_spare_parameter
_second_spare_parameter
_third_spare_parameter
_fourth_spare_parameter
_fifth_spare_parameter
_sixth_spare_parameter
_seventh_spare_parameter

 Anyway, that’s it for now. I hope you have a happy holiday and a …

When I got to work today I walked into my co-worker’s (Michael’s) office and saw this:

Data was scrolling by on the screen in rapid fashion. So I asked him what he was doing and he said he got tired of mashing the inner-butt-n  (that’s the way we say “pressing the the return key” in Texas). Works for me. He could have probably written a custom shell script with proper error checking and whatnot, but why, when the stapler was sitting right there.

I always thought the best programmers were basically lazy. They always seem to find ways to get more done in less time. When I was a young programmer my goal was to write a batch job that would run all month. That way I’d only have to come in on the first to kick it off for the next month. I never quite got there but I had fun trying.

Which reminds me of something that happened at my first programming job. I worked for an oil company that had more money than sense. We had two of everything. We actually had two Cray’s. Anyway, my boss had one of the very first transportable computers, a Grid. The Grids were very futuristic back in 1982. They looked pretty similar to what we have today. So anyway, my boss told me this story after returning from trip with his brand new Grid. He said he was on the airplane and decided to get his new toy out and play with it. So he gets it out of the bag and sets it up on the tray (I guess it was after the flight had taken off due to the electronics restrictions, oh yeah, they didn’t have those then!) – so anyway, he starts getting all the stuff out of the bag and getting organized, and by this time he says everyone within 10 rows is staring at him because no one had ever seen a laptop computer before. And he’s looking around smiling at everyone, thinking yeah this is pretty cool. Then he gets the last part out of the bag, … a power cord.

and he looks at the power cord …

and he looks around the cabin for a place to plug it in …

and he looks at the power cord again …

They didn’t have batteries on those early models. (they didn’t have ethernet jacks either, but they did have a 1200 baud modem BUILT IN!)  So anyway, he sheepishly puts the computer back in the bag and pretends to sleep for the rest of the flight.

Here’s a picture of the Grid computer (notice the wire running out the back <grin>):

My favorite low tech solution though was provided by a friend of mine that got a job right out of college working for an oil company. His first assignment was to fix a bug in an extremely complex reservoir simulation program. Apparently they had been trying to fix the bug for months.  The bug manifested itself by producing a result for one of the calculations that was always off by 1. And they just couldn’t figure out where the error was. They ran test case after test case through it and it was always off by 1. My friend worked on it for a day and then demoed it for them and it worked flawlessly. When asked how he did it, he said “Well, I just went to the end of the program and added 1 to the result”.

Your comments are always welcome.

Roughly 10 years ago, Oracle introduced a way to lock down execution plans. This was a response to the inherent unpredictability of the early cost based optimizer. The Oracle marketing machine even gave the feature the name “Plan Stability”. It appeared to be a good approach, basically allowing a DBA to lock an existing plan for a given statement. The mechanism employed to accomplish this was to create hints that didn’t allow the optimizer much (if any) flexibility to come up with an alternative plan. These hints are stored in the database in a structure called an OUTLINE or sometimes a STORED OUTLINE. The optimizer could then apply these hints behind the scenes whenever a SQL statement that matched was executed. By the way, “matching” basically means that the text of the statement matches. Originally outlines had to match character for character just like the normal rules for sharing SQL statements, but for some reason, Oracle later decided that the matching algorithm should be somewhat relaxed as compared to Oracle’s standard. What that means is that in 10gR2 by default whitespace is collapsed and differences in case are ignored. So (at least as far as outlines are concerned)  “select * from dual” is the same as “SELECT     *       FROM DuAl”. You’ll still get two different statements in the shared pool but they will use the same outline, if one exists.

With 9i, Oracle started to enhance this feature by adding the ability to edit the outlines themselves, but they never really completed the job. They pretty much quit doing anything with the feature after 9i. In fact, the script that creates the DBMS_OUTLN package ($ORACLE_HOME/rdbms/admin/dbmsol.sql) has not been updated since early in 2004 (with the exception of a tweak to keep it working in 11g). Anyway, I think it is a great feature with two primary uses.

• First, it can be used to freeze a plan for a statement. This is especially helpful in situations where bind variable peeking is causing Oracle to alternate between a couple of plans.
• Second, it can be very helpful when dealing with an application where the code can not be modified. Outlines provide a means of altering the execution plan for a statement without changing the code or making changes to the basic database configuration.

Lot’s of people have written about outlines, so I don’t want to just repeat information that is already available. But there doesn’t seem to be a single spot that pulls together all (at least what I consider to be all) the important stuff. Also, most of the stuff I have seen about outlines was written for 8i or 9i. As this is being written, 11gR1 has been out for over a year (although it has still not been widely adopted), and 10gR2 is far and away the most prevalent version in production. So, here we go.

Outlines can be created two ways.

1. You can use the CREATE OUTLINE statement – which allows you to give your outline a name, but requires you to include the SQL statement as part of your CREATE OUTLINE statement. Therefore you can’t see what the execution plan is before creating the outline. Not very useful in my opinion.
2. You can use the CREATE_OUTLINE procedure in the DBMS_OUTLN package – which doesn’t allow you to give your outline a name, but does let you specify a specific child cursor of a specific SQL statement in the shared pool. This means you can check the execution plan before creating the outline and that you can be sure the statement exactly matches what is being sent from the application.

Here’s an example:

CREATE OUTLINE myoutline FOR CATEGORY temp ON select * from dual;

EXEC DBMS_OUTLN.CREATE_OUTLINE('82734682234',0,'DEFAULT');

Continue reading ‘Oracle Outlines – aka Plan Stability’ »

I posted earlier about the ability to flush a single SQL statement out of the shared pool in 11g (also back ported to 10.2.0.4 with a bit of extra work) here. If you are on an earlier release of Oracle though, you can accomplish the same thing by creating an outline on the statement using the DBMS_OUTLN.CREATE_OUTLINE procedure. I just discovered this recently, so let me know if I just missed this trick. Anyway, prior to noticing this affect of creating an outline, my best options to flush a statement were:

• flush the shared pool – not a very appealing option in a production environment (although I see almost the same affect frequently at sites that gathering stats every night).
• modify an object that the statement depends on – I usually would add a comment to one of the tables used by the statement. Unfortunately, all statements that use the table will be flushed, so this technique can also be a little hard on a production system, but it’s certainly better than flushing the whole shared pool. 

So I wrote a little script (like I always do) and called it flush_sql10.sql. There are a couple of things to be aware of with it.

1. I don’t like having to find the hash_value that the create_outline procedure uses, so I prompt for the sql_id and then let the script find the hash_value.
2. The create_outline procedure requires a child number, but the flushing affect is not limited to the specified child. All children for the specified statement will be flushed.
3. The script drops the outline after creating it (since the purpose is to flush the statement, not to create an outline). This part is a little dicey since the create_outline procedure does not return an identifier for the outline that gets created. Nor does it allow you set a name for the outline. So I coded it to drop the most recently created outline (which should be sufficient, since it would be highly unlikely that more than one person would be creating outlines at the same time). But wait, don’t answer yet, I also limited the drop to outlines created in the last 5 seconds. Bottom line, it is unlikely that an unintended outline would be accidentally dropped by the script. (you have however been forewarned!)
4. There’s no error checking. Any errors stop execution of the script and are passed back to the user. The most common error is to not give it a valid SQL_ID, CHILD_NO combination. In this case the create_outline procedure fails and the script exits with a “no data found” message.

Here’s an example:

> sqlplus / as sysdba

SQL*Plus: Release 10.2.0.3.0 - Production on Fri Dec 12 08:31:08 2008

Copyright (c) 1982, 2006, Oracle.  All Rights Reserved.


Connected to:
Oracle Database 10g Enterprise Edition Release 10.2.0.3.0 - Production
With the Partitioning, OLAP and Data Mining options

SQL> @find_sql
Enter value for sql_text: %skew%
Enter value for sql_id:

SQL_ID         CHILD  PLAN_HASH      EXECS     AVG_ETIME      AVG_LIO INVALIDATIONS    SQL_TEXT
------------- ------ ---------- ---------- ------------- ------------ ------------- -----------------------------------------------------
0gza16w5ka67q      0 1528838287          1           .01          249             0 SELECT   count(*)    FROM kso.skew where pk_col < 10
688rj6tv1bav0      0 3723858078          1          2.15       37,270             1 select avg(pk_col) from kso.skew where col1 = 1
688rj6tv1bav0      1  568322376          1          5.09      173,731             1 select avg(pk_col) from kso.skew where col1 = 1
7cbu7dgt0vh6y      0 1528838287          1           .00          226             0 select count(*) from kso.skew where pk_col < 10

SQL> @flush_sql_ol

Session altered.

Enter value for sql_id: 688rj6tv1bav0
Enter value for child_number: 1

SQL Statement 688rj6tv1bav0 flushed.
(Note also that outline SYS_OUTLINE_08121120170934217 was dropped.)

PL/SQL procedure successfully completed.

SQL> @find_sql
Enter value for sql_text: %skew%
Enter value for sql_id:

SQL_ID         CHILD  PLAN_HASH      EXECS     AVG_ETIME      AVG_LIO INVALIDATIONS    SQL_TEXT
------------- ------ ---------- ---------- ------------- ------------ ------------- -----------------------------------------------------
0gza16w5ka67q      0 1528838287          1           .01          249             0 SELECT   count(*)    FROM kso.skew where pk_col < 10
7cbu7dgt0vh6y      0 1528838287          1           .00          226             0 select count(*) from kso.skew where pk_col < 10