■ FOREWORD FROM THE FIRST EDITION
xviii
Foreword
I first met the Oracle RDBMS some time in 1988, or possibly 1987, when my manager dumped a small
box on my desk and said something like: “There’s this new product called Oracle just coming into the
country. Play around with it for a few weeks and then tell us what it’s good for.”
The version was something like 5.0.22, and in those days it was a lot easier getting started with
Oracle. The entire printed manual set—including Forms 2.0, SQL*Report, and everything else—would fit
into a small briefcase and the documentation for the create table statement ran to about three pages.
If you check the PDF file for the 11.2 SQL reference manual, you’ll find that create table currently
starts at page 16-6 and runs on to page 16-79 for a total of 74 pages. The last time I checked the total page
count was for 9i, and that was more than 20,000 pages—and I doubt if the number has dropped in 10g
and 11g.
With three (fairly slim) manuals for 5.0.22, it didn’t take me very long to learn about everything that
Oracle was supposed to do and how to do it efficiently. There weren’t many options, so there weren’t
many ways to do things wrong. But how do you get started today when the core of Oracle is hidden
under a huge mass of options and features? Worse, the details you really need to understand are covered
by a mountain of information that is nice to have, but not critical to getting started.
The answer is simple.
Step 1: Read the concepts manual so you have an idea of what it’s all about.
Step 2: Read Tom Kyte’s book so that you can follow a rational progression of learning and
experimenting that leads you from your first “select ‘hello world’ from dual” to the day when you can
confidently say things like “we should use a range partitioned IOT with these columns in the overflow for
this table because … .”
Tom combines three things in this book: a conversational style that makes it easier to read about
technical details and understand the “why” behind the “how”; a structured “storyline” so that you see
the text building towards a target rather than scattering a disjointed collection of random tips; and an
array of carefully constructed demonstrations that teach you how things work and how you should work
and think.
Consider just one example, indexing. There are many types of indexes, so we need a brief
introduction to separate the different types. It’s good to have an idea of how B-tree indexes (for example)
actually work so that we can understand their strengths and weaknesses. Then we can move on to the
idea of function-based indexes—indexes on “data that don’t really exist.” This gets us to the point of
understanding what Oracle can do, but we can (and do) go further with what we can do with Oracle. So
we see how we can put the pieces together to create an index that guarantees uniqueness across subsets
of the data, we see how we can—on a huge data set—create a tiny, low-maintenance index that identifies
exactly the data that we really want to access and minimizes the risk of the optimizer producing a silly
execution plan.
In principle, it’s all in the manuals, but only if we have the insight to take the naked descriptions of
the available commands and see how we can use them to construct solutions to real problems. Tom Kyte
supplies that insight, and then encourages you to go further in developing your own insights.
Frankly, if every DBA and developer in the world were made to work carefully through Tom Kyte’s
book, I’d probably have to start offering consultancy services to SQL Server users because the number of
clients needing Oracle consultancy would drop dramatically.
Jonathan Lewis