ORACLE-BASE Blog Aggregator

Are You Soft on Your Deletes?

Eddie Awad — Mon, 15 Mar 2010 14:00:08 +0000

Frustrated with soft deletes in SQL, Reeditor writes:

In the past, I’ve added a deleted_at (datetime) column and appended “WHERE deleted_at IS NULL” to every query involving that table. But it’s a total pain in the ass, and it’s complicated as shit: there’s always a few queries that are missed, a few developers that forgot or didn’t know they had to check that the record wasn’t deleted, denormalized counts are hard to keep in sync, etc. etc. It always turns into an embarrassing fiasco rather than something you add once and then don’t have to worry about.

Good discussion followed which included a couple of interesting links: What is the best way to implement soft deletion? and The trouble with soft delete.

So, if there is a business need to retain deleted records, do you go soft or hard?

Advert – MOW

Jonathan Lewis — Mon, 15 Mar 2010 09:06:20 +0000

I’ve just noticed that Miracle Open World is less than a month away – so I just had to bounce this advert to the top of the blog to remind people about this event, which probably has the highest concentration of international speaker per square metre of any Oracle conference in the world. But you [...]

APEX 4.0 – New Features Application and Description

Dimitri Gielis — Sun, 14 Mar 2010 17:19:00 +0000

If you didn't have time to review APEX 4.0 Early Adopter I and II, but you want to have a quick look what new features will be in APEX 4.0, you can do that now...

There is an APEX 4.0 New Features Application which shows a lot of the new features in action.
e.g. the screenshot below shows the new features for tabular forms in action.

If you want more detail about the new features and when they got introduced (e.g. you reviewed EA1 but want to see what is new in EA2), you can go to the APEX 4.0 New Features Description.

I find it very useful to have something like above.

The Hello World Collection

Eddie Awad — Sun, 14 Mar 2010 02:37:18 +0000

“Hello World” is the first program one usually writes when learning a new programming language. The first Hello World program appeared in chapter 1.1 of the first edition of The C Programming Language, in 1978. Since then, Hello World has been implemented in just about every programming language on the planet.

The Hello World collection includes 428 Hello World programs in many more-or-less well known programming languages, plus 63 human languages.

Can you name the programming language based on its Hello World syntax? Take this quiz and let us know. (via)

Arriving at NZOUG…

Tim... — Sat, 13 Mar 2010 23:50:34 +0000

I walked off the 7 hour flight to Dubai, straight on to the 13+ hour flight to Melbourne. I got a 1 hour rest at Melbourne while they cleaned the plane, before I started the 3+ hour flight to Auckland. I got to Auckland at about 14:00 where I was met by one of my friends. I was whisked straight back to his house and spent the rest of the day catching up on everything that happened since my last skype call ( 4 days before ) and playing with their kid.

The following day was mostly spent with a trip to some of my friends relatives and general idle conversation. Very low pressure. Very cool. The funny thing is, it’s about 18 months since I was last here and I feel like I never left.

This morning I got up early to pick Chris Muir up from the airport, where I bumped into Dan Morgan, not literally. Chris was delayed, so after a bit of messing about we got on our way to Rotorua. The roads were quiet so we made good time and I’m now in the hotel ready to go. We have a little get together tonight, then the conference starts tomorrow.

I guess I’ll do a run through of my presentations now, and maybe sleep a little later.

Cheers

Tim…

Database Backups in 10 Minutes (Video)

Eddie Awad — Sat, 13 Mar 2010 19:00:23 +0000

A good overview of the most common types of database backups and how they compare to each other.

Explain adaptive cursor sharing behavior with cursor_sharing = similar and force.

Optimizer Development Group — Sat, 13 Mar 2010 01:00:00 +0000

Here's another question that was submitted during the OpenWorld Optimizer Roundtable. It's a common question that we've discussed a little bit in a couple other posts, but we wanted to summarize everything in one place.

First, let’s quickly review what the different values for the cursor_sharing parameter mean. We discussed this behavior in some detail in an earlier post about cursor_sharing. Below is a summary of the behavior of the different values in different cases (copied from the earlier post):

CURSOR_SHARING VALUE	SPACE USED IN SHARED POOL	QUERY PERFORMANCE
EXACT (No literal replacement)	Worst possible case - each stmt issued has its own parent cursor	Best possible case as each stmt has its own plan generated for it based on the value of the literal value present in the stmt
FORCE	Best possible case as only one parent and child cursor for each distinct stmt	Potentially the worst case as only one plan will be used for each distinct stmt and all occurrences of that stmt will use that plan
SIMILAR without histogram present	Best possible case as only one parent and child cursor for each distinct stmt	Potentially the worst case as only one plan will be used for each distinct stmt and all occurrences of that stmt will use that plan
SIMILAR with histogram present	Not quite as much space used as with EXACT but close. Instead of each stmt having its own parent cursor they will have their own child cursor (which uses less space)	Best possible case as each stmt has its own plan generated for it based on the value of the literal value present in the stmt

Adaptive cursor sharing (ACS) is another feature we've blogged about before, which allows the optimizer to generate a set of plans that are optimal for different sets of bind values. A common question is how the two interact, and whether users should consider changing the value of cursor_sharing when upgrading to 11g to take advantage of ACS. The simplest way to think about the interaction between the two features for a given query is to first consider whether literal replacement will take place for a query. Consider a query containing a literal:

select * from employees where job = 'Clerk'

As we see from the table above, the treatment of this query by literal replacement will depend on the value of the cursor_sharing parameter and whether there is a histogram on the job column. Here are the interesting cases:

Cursor_sharing = exact. No literal replacement will take place, and the optimizer will see the query as is.

Cursor_sharing = force. Whether there is a histogram or not, literal replacement will take place, and the optimizer will optimize the query as if it were:

select * from employees where job = :b

Bind peeking will take place, so that the value "Clerk" is used to generate cardinality estimates for the query. Subsequent executions of this query differing only in the literal value will share the same plan.

Cursor_sharing = similar. There are two different cases for this:
1. There is a histogram on the job column. In this case, literal replacement will not take place. The presence of a histogram indicates that the column is skewed, and the optimal plan may depend on the literal value. Hence, the optimizer sees the query as:
  
  select * from employees where job = 'Clerk'
  
  and subsequent executions with a different literal will not necessarily use the same plan.
2. There is no histogram on the job column. This indicates that the column is not skewed, and the optimizer is likely to choose the same plan no matter the literal, so literal replacement takes place.

Now that we know when literal replacement will take place, and what the query looks like to the optimizer, we can consider adaptive cursor sharing. If literal replacement takes place, and the query that the optimizer optimizes contains a bind, then adaptive cursor sharing can take place. To adaptive cursor sharing, a bind variable is a bind variable, whether it comes from the user query or is inserted by literal replacement. On the other hand, if the query contains only literals (no binds), adaptive cursor sharing will not take place. In our example above, adaptive cursor sharing can be considered for cases 2 and 3.2. For case 3.2, it is likely that the optimizer will choose the same plan for different values of the literal. In case 2, if there is a histogram, then the optimizer may choose different plans depending on how popular the literal value is.

This example shows that if you use histograms, and want the optimizer to choose an optimal plan for different literal values using ACS, then you should set cursor_sharing to force. If it is set to similar, then literal replacement will not take place, and a child cursor will be created for each value of the literal. Setting cursor_sharing to similar effectively disables ACS for these kinds of queries. By setting cursor_sharing to force and letting adaptive cursor sharing kick in, the optimizer can choose optimal plans for different values, but if the same plan is appropriate for several values, they will share a single child cursor. Historically, cursor_sharing=similar has been recommended as a middle ground between no literal replacement (which causes a lot of cursors to be generated) and forced literal replacement (which causes a potentially sub-optimal plan to be shared for all literals). We now recommend using adaptive cursor sharing along with cursor_sharing=force instead.

So far we have only discussed cursor sharing in the presence of histograms. There are other cases where the optimizer's choice of plan can depend on the specific literal that appears in the query, for instance when binds appear in range predicates or when a bind value falls outside of a column's range (according to the optimizer statistics). Binds appearing in these kinds of predicates are also considered by adaptive cursor sharing, whereas they are not considered by cursor_sharing=similar.

Sample Clause

Jonathan Lewis — Fri, 12 Mar 2010 17:22:01 +0000

In some of my previous posts (particularly the ones about analysing the data by running aggregate queries) I’ve mentioned the “sample” clause from time to time, so I thought I’d better write a short note about it for those not familiar with it. To demonstrate the feature, my first step was to run a test script [...]

Word count in Pages (OSX)

Dimitri Gielis — Fri, 12 Mar 2010 08:55:00 +0000

Sometimes it's hard to find something if you don't use it that much.

I was searching for a Word and Character count in Pages (OSX). Pages is like Word, but than from Apple. Anyway, in Pages most nice "things" are under the Inspector icon.

The first icon (Document) and the third tab in there, give you what you need. Information about your document, like the number of words you used, number of characters etc.

The better you know something, the faster you can get what you want, it applies to everything ...

Upgrading to R12.1.2, Tip #1

Jeff Hunter — Thu, 11 Mar 2010 23:11:00 +0000

While applying patch 7303033 on top of a 12.1.0 R12 installation, I got the following error in one of my workers: FNDLOAD APPS/***** 0 Y UPLOAD @FND:patch/115/import/afscursp.lct @JTF:patch/115/import/US/jtfdiagresp.ldt - Connecting to APPS......Connected successfully. Calling FNDLOAD function. Returned from FNDLOAD function. Log file: /r12u/apps/apps_st/appl/admin/UPG/log/