Saturday, December 10, 2005

Tom Kyte Event in Zuerich Dec. 7th.-9th.

Oracle University managed to get Tom Kyte to come over to Switzerland and deliver a 3-day seminar.
More than 40 Oracle experts from different countries came to the Zurich Development Center to take part in this Top-Event.

During these three days Tom Kyte delivered a number of 90 to 120 min. sessions in which he covered a great variety of issues which are crucial for a high performance database

Discussions were hot and even during the breaks Tom Kyte did not refuse to answer questions of the audience.

The event was a great success and everybody was happy to be there.

Here is a list of the sessions Tom Kyte delivered:
(see also Laurent Schneider's blog for more detailed info)

1. Things you "know"Abstract:

Many developers and DBAs (not all, but many) approach the database with little or no understanding of how it actually works. Developers approach Oracle assuming it must work just like SQL Server or even worse with the frame of mind that says, "It doesn't matter how it works, I'm using a layer of abstraction to protect me." DBAs approach the server sometimes with a cursory knowledge of how things work, leading them to do things like, "We can skip backing up undo data-it isn't our stuff, we don't need it" or erasing archives because they ran out of space. This presentation will present some of these foibles and explain how not understanding how the database actually works will lead to disaster. Some examples of things you just might not know about yourself will be explored. Oracle is big and it is a moving target. Understanding it is an ongoing process that we need to continually do.. This is a "keynote" type of presentation, not extremely technical, but more introspective about the "things you just know..."

2. All about binding -1 to 1.5 hours:

We'll briefly overview why it is extremely important with regards to performance, scalability and even security but quickly move into topics such as:
Do I always want to bind? (Surprisingly, the answer is no.)
What is bind variable peeking?
Is it good or evil in disguise or a bit of both?
So the developers don't bindis cursor_sharing=force/similar appropriate system wide? (Emphasis will be on the reasons why setting cursor sharing at the instance level is not such a good idea.)
What is the real difference between cursor_sharing=force/similar and which should we use under what circumstances? The presentation will be practical, with many examples and hard numbers you can use in your day-to-day work.

3. SQL Techniques -1 to 1.5 hours:

The presenter will describe common SQL techniques he has encountered and utilizes day to day to tune query performance. Features such as scalar subqueries, using rownum (yes, to 'tune'), analytics, some hints and more will be demonstrated. Emphasis will be on when they work (where the 'trick' applies) as well as when they don't workwhere they do not apply. Care will be taken to show these not as a "top 10 things to do" but rather techniques to keep in mind when looking at problems in general.

4. The tools Tom uses - 1.5 hours:

This first session gives an overview of (and practical use examples of) the common tools every Oracle developer and database administrator should master. Using AUTOTRACE and DBMS_XPLAN, TKPROF, and StatsPack. Tom will show how these tools relate to functionality in Oracle 10g Enterprise Manager DBconsole. Additionally, more in depth tools are covered, such as DBMS_PROFILER, a self developed tool for benchmarking ideas "runstats", and using JDeveloper as a PL/SQL developer.

5. Efficient schema design - 1.5 hours:

Based entirely on chapter 7 of Tom's book "Effective Oracle by Design", this session takes you through the fundamentals of physical schema design. It demonstrates the various structures (hash clusters, B*-tree clusters, index-organized tables, ...) and tells when and where you want to use them. The session closes with indexing and compression techniques.

6. Advanced analytic functions - 1 to 1.5:

hours Analytic functions are the coolest thing to happen to the SQL language since the introduction of the keyword SELECT. This session explores the use cases for analytic functions, demonstrates how and where you should use them, and explains the (nontrivial) syntax behind them.

7. To Hint or not to Hint, that's the question - 0.5 hours:

There are good hints -- hints that give the optimizer information -- and there are "bad" hints, hints that take over the job of the optimizer. We'll explore the differences between the two, learn what good hints are and when (not) to apply them. We'll also look at optimizer dynamic sampling, system level statistics, and other optimizer related settings in the Oracle database.

8. Read and write consistency - 1.5:

hours Oracle's multiversioning model is by far it's most striking core RDBMS feature. We'll explore this often misunderstood database feature, both from a "read" perspective as well as some nuances you probably are not aware of in a multi-user environment. This session is probably an eye-opening experience, even for people that have been using Oracle for many many years.

9. Versioning of data - 0.75 to 1 hour:

A common requirement today is to maintain a complete history of data: every change made to a row over time, for all rows in a table or set of tables. This session explores the methods available to do this, from "do it yourself" versioning (via triggers/application code) to letting the database do it for you with workspace management. Key focuses of this session are time to develop, performance, and implementation.

10. The Top 5 things done wrong over and over again - 0.75 to 1 hour:

This session covers the top 5 things Tom Kyte has seen done wrong over and over again, based on questions to the site as well as interaction with customers in the field.

11. Building test cases - 0.5 to 0.75 hours:

When you say "it doesn't work", or "it isn't working right", you will need to build a small, concise, yet 100% complete test case that demonstrates the issue at hand (and removes all of the irrelevant bits). This session walks through how Tom Kyte builds his own test cases -- and how he many times finds his own mistakes in the development of them (such as: it wasn't a database bug in the first place!) - or, even if it turns out to be a problem in the database, how the development of the test case often leads to finding a workable "workaround".

12. PL/SQL or Java? - 0.5 to 0.75 hours:

Is one language "better" than the other? Or maybe there is room for both? This session explores when you might want to use one over the other.

13. Oracle 10g: So, is tuning dead? - 0.5 to 0.75 hour:

With Oracle 10g you no longer have to tune, right? The database just does it for you. This session will explore what is left for the database administrator or developer to do in Oracle 10g.

14. All about Flashing back - 1.5 hours:

This session covers all of the flashback areas:
flashback query,
flashback table,
flashback row history,
flashback drop, and
flashback database. Tom explains how each feature is physically implemented; for example, what settings like undo_retention and guaranteed undo retention mean and what they do. This session is very in depth (on the "how") so database administrators can be prepared to allow these features to be used in their database environments.

15. Oracle 10g: Bits and bytes - 1.0 to 1.5 hours:

This session covers some Oracle 10g features that are really "cool" but not played up in the Oracle marketing messages. Mundane features that make our day to day lives that much nicer. Features such as case insensitive queries, native floating point numbers, data pumping, unloading data, a better merge, partitioned outer joins, and many more features.


Post a Comment

<< Home