Tài liệu Expert Oracle

About the Author
I am Tom Kyte. I have been working for Oracle since version 7.0.9 (that's 1993 for people who
don't mark time by Oracle versions). However, I've been working with Oracle since about
version 5.1.5c ($99 single user version for DOS on 360 KB floppy disks). Before coming to work
at Oracle, I worked for more than six years as a systems integrator, building large scale,
heterogeneous databases and applications, mostly for military and government customers. These
days, I spend a great deal of my time working with the Oracle database and, more specifically,
helping people who are using the Oracle database. I work directly with customers, either in
specifying and building their systems or, more frequently, helping them rebuild or tune them
('tuning' frequently being a synonym for rebuilding). In addition, I am the Tom behind 'AskTom'
in Oracle Magazine, answering people's questions about the Oracle database and tools. On a
typical day I receive and answer 30 to 40 questions at http://asktom.oracle.com. Every two
months, I publish a 'best of' in the magazine (all of the questions asked are available on the Web
– stored in an Oracle database of course). Basically, I spend a lot of my time helping people be
successful with the Oracle database. Oh yes, in my spare time, I build applications and develop
software within Oracle Corporation itself.
This book is a reflection of what I do everyday. The material within, covers topics and questions
that I see people struggling with every day. These issues are covered from a perspective of 'When
I use this, I do it this way'. It is the culmination of many years experience of using the product, in
a myriad of situations.
Acknowledgments
I would like to thank many people for helping me complete this book. At Oracle, I work with the
best and brightest people I have ever known, and they all have contributed in one way or another.
Specifically, I would like to thank Joel Kallman for his help in developing the interMedia section of
this book. When working on 'AskTom', I frequently go to Joel for help in this area – Joel is 'the
man', when it comes to interMedia and related technologies. I would also like to thank David Knox
for his help in developing the SSL-based examples in the UTL_HTTP section. Without his diligence
and willingness to help me figure it all out, this section would not exist. Lastly, I would like to thank
everyone I work with for their support during this book-writing ordeal. It took a lot more time and
energy than I ever imagined, and I appreciate their flexibility in that regard. In particular, I would
like to thank Tim Hoechst and Mike Hichwa, whom I've worked with and known for almost 10
years now – their constant questioning and pushing helped me to discover things that I would
never have even thought of investigating on my own.
I would also like to acknowledge the people who use the Oracle software and ask so many good
questions. Without them, I would never even have thought of writing this book. Much of what is
found here is a direct result of someone asking me 'how' or 'why,' at one time or another.
Lastly, but most importantly, I would like to acknowledge the unceasing support I've received
from my family. You know you must be important to someone when you hear 'but Dad, why are
you still writing that book?' for about the hundredth time. Without the continual support of my
wife Lori, son Alan, and daughter Megan I don't see how I could have finished this.
Download at Boykma.Com
Foreword
“THINK.” In 1914, Thomas J. Watson, Sr. joined the company that was to become IBM, and he
brought with him this simple one-word motto. It was an exhortation to all IBM employees, no
matter their role, to take care in decision-making and do their jobs with intelligence. “THINK”
soon became an icon, appearing on publications, calendars, and plaques in the offices of many
IT and business managers within and outside IBM, and even in The New Yorker magazine
cartoons. “THINK” was a good idea in 1914, and it is a good idea now.
“Think different.” More recently, Apple Computer used this slogan in a long-running advertising
campaign to revitalize the company’s brand, and even more important, to revolutionize how
people think of technology in their daily lives. Instead of saying “think differently,” suggesting
how to think, Apple’s slogan used the word “different” as the object of the verb “think,”
suggesting what to think (as in, “think big”). The advertising campaign emphasized creativity and
creative people, with the implication that Apple’s computers uniquely enable innovative
solutions and artistic achievements.
When I joined Oracle Corporation (then Relational Software Incorporated) back in 1981,
database systems incorporating the relational model were a new, emerging technology.
Developers, programmers, and a growing group of database administrators were learning the
discipline of database design using the methodology of normalization. The then unfamiliar nonprocedural
SQL language impressed people with its power to manipulate data in ways that
previously took painstaking procedural programming. There was a lot to think about then—and
there still is. These new technologies challenged people not only to learn new ideas and
approaches, but also to think in new ways. Those who did, and those who do, were and are the
most successful in creating innovative, effective solutions to business problems using database
technology to its best advantage.
Consider the SQL database language that was first introduced commercially by Oracle. SQL
permits application designers to manipulate sets of rows with a non-procedural (or “declarative”)
language, rather than writing iterative loops in conventional languages that process records one
at a time. When I was first introduced to SQL, I found it required me to “think at 45 degrees” to
figure out how to use set processing operations like joins and subqueries to achieve the result I
wanted. Not only was the idea of set processing new to most people, but so also was the idea of a
non-procedural language, where you specified the result you wanted, not how to derive it. This
new technology really did require me to “think differently” and also gave me an opportunity to
“think different.”
Set processing is far more efficient than one-at-a-time processing, so applications that fully
exploit SQL in this way perform much better than those that do not. Yet, it is surprising how
often applications deliver suboptimal performance. In fact, in most cases, it is application design,
rather than Oracle parameter settings or other configuration choices, that most directly
determines overall performance. Thus, application developers must learn not only details about
database features and programming interfaces, but also new ways to think about and use these
features and interfaces their applications.
Much “conventional wisdom” exists in the Oracle community about how to tune the system for
best performance or the best way to use various Oracle features. Such “wisdom” sometimes
Download at Boykma.Com
becomes “folklore” or even “mythology,” with developers and database administrators adopting
these ideas uncritically or extending these ideas without reasoning about them.
One example is the idea that “if one is good, more—lots more—is better.” This idea is popular, but
only rarely true. Take Oracle’s array interface, for example, which allows the developer to insert
or retrieve multiple rows in a single system call. Clearly, reducing the number of network
messages between the application and the database is a good thing. But, if you think about it,
there is a point of diminishing returns. While fetching 100 rows at once is far better than one at a
time, fetching 1,000 rows at once instead of 100 is generally not really any more efficient overall,
especially when you consider memory requirements.
Another example of uncritical thinking is to focus on the wrong aspects of system design or
configuration, rather than those most likely to improve performance (or, for that matter,
reliability, availability, or security). Consider the “conventional wisdom” of tuning the system to
maximize the buffer hit ratio. For some applications, it’s true that maximizing the chance that
required data is in memory will maximize performance. However, for most applications it’s
better to focus attention on performance bottlenecks (what we call “wait states”) than it is to focus
on specific system-level metrics. Eliminate those aspects of the application design that are
causing delays, and you’ll get the best performance.
I’ve found that breaking down a problem into smaller parts and solving each part separately is a
great way to think about application design. In this way, you can often find elegant and creative
uses of SQL to address application requirements. Often, it is possible to do things in a single
SQL statement that at first seem to require complex procedural programming. When you can
leverage the power of SQL to process sets of rows at a time, perhaps in parallel, not only are you
more productive as an application developer, but the application runs faster as well!
Sometimes, best practices that were based, even in part, on some degree of truth become no
longer applicable as the facts change. Consider the old adage, “Put indexes and data in separate
tablespaces for best performance.” I’ve often seen database administrators express strong
opinions over the merits of this idea, without taking into account changes in disk speeds and
capacities over time, or the specifics of given workloads. In evaluating this particular “rule,” you
should think about the fact that the Oracle database caches frequently and recently used database
blocks (often blocks belonging to an index) in memory, and the fact that it uses index and data
blocks sequentially, not simultaneously, for any given request. The implication is that I/O
operations for both index and data really should be spread across all simultaneous users, and
across as many disk drives as you have. You might choose to separate index and data blocks for
administrative reasons or for personal preference, but not for performance. (Tom Kyte provides
valuable insights on this topic on the AskTom.oracle.com website, where you can search for
articles on “index data tablespace”.) The lesson here is to base your decisions on facts, and a
complete set of current facts at that.
No matter how fast our computers or how sophisticated the database becomes, and regardless of
the power of our programming tools, there simply is no substitute for human intelligence coupled
with a “thinking discipline.” So, while it’s important to learn the intricacies of the technologies
we use in our applications, it’s even more important to know how to think about using them
appropriately.
Tom Kyte is one of the most intelligent people I know, and one of the most knowledgeable about
the Oracle database, SQL, performance tuning, and application design. I’m pretty sure Tom is an
aficionado of the “THINK” and “Think different” slogans. Tom quite obviously also believes in
that anonymous wise saying, “Give a man a fish and you feed him for a day. Teach a man to fish
and you feed him for a lifetime.” Tom enjoys sharing his knowledge about Oracle, to the great
Download at Boykma.Com
benefit of our community, but rather than simply dispensing answers to questions, he helps
others learn to think and reason.
On his website (AskTom.oracle.com), in his public speaking engagements, and in this book,
Tom implicitly challenges people to “think differently” too, as they design database applications
with the Oracle database. He rejects conventional wisdom and speculation, instead insisting on
relying on facts proven through examples. Tom takes a very pragmatic and simple approach to
problem solving, and by following his advice and methodology, you can be more productive and
develop better, faster applications.
Not only will Tom’s book teach you about features of Oracle and how to use them, but it also
reflects many of these simple thoughts:

❑ Don’t believe in myths—reason for yourself.
❑ Don’t follow “conventional wisdom”—often the things everybody knows are simply
wrong!
❑ Don’t trust rumors or opinions—test things for yourself and base decisions on proven
examples.
❑ Break apart a problem into simpler questions, and assemble the answers to each step
into an elegant, efficient solution.
❑ Don’t do things in your programs when the database can do them better and faster.
❑ Understand the differences between the ideal and the real.
❑ Ask questions about and be skeptical of unjustified “company policies” for technical
standards.
❑ Consider the big picture of what’s best overall for the requirements at hand.
❑ Take the time to THINK.

Tom encourages you to treat Oracle as much more than a black box. Instead of you just putting
data into and taking data out of Oracle, Tom will help you understand how Oracle works and
how to exploit its power. By learning how to apply Oracle technology creatively and
thoughtfully, you will be able to solve most application design problems quickly and elegantly.
As you read and enjoy this book, I know you’ll learn a lot of new facts about Oracle database
technology and important concepts about application design. As you do, I’m confident that you’ll
also start to “think differently” about the challenges you face.

IBM’s Watson once said, “Thought has been the father of every advance since time began. ‘I
didn’t think’ has cost the world millions of dollars.” This is a thought with which both Tom and I
agree. Armed with the knowledge and techniques you’ll learn in this book, I hope you’ll be able
to save the world (or at least your enterprise) millions of dollars, and enjoy the satisfaction of a
job well done.
Ken Jacobs
Vice President of Product Strategy (Server Technologies), Oracle Corporation

Download at Boykma.Com
Dear Reader,
This book was a year in the making and, as of the release of this Signature Edition, it has been
about four years since it was first published. In those five years since I first put fingers to
keyboard, much has changed in Oracle, but much has stayed the same.
We’ve progressed from Oracle 8i Release 3 (version 8.1.7), the release upon which this book is
based, through two 9i releases, to the current Oracle 10g Release 1 (with Release 2 already
imminent!). With each new release inevitably come some changes to architectural
implementations in the Oracle server software, along with new features that make our jobs easier,
such as SQL Profiles, all online operations, and faster PL/SQL.
However, while certain details are different, what strikes me equally, as I begin work on the
forthcoming 9i/10g edition of the book, is just how much has remained the same. The basic
database features of concurrency control, transactions, recovery, and data integrity are more or
less the same today as they were in 2001 and, in fact, as they were in 1991. By extension, the
basics of good Oracle database application design have not changed fundamentally over the
years. Individual database features may have changed, but the core has not, and my book
emphasizes this “core.”
I encourage you to read this book with that in mind. In it, I try to demonstrate the concepts via
examples—and I encourage you to do the same. Try them out yourself. You may well find the
details have changed slightly from release to release, but the broad concepts remain exactly the
same. By having a sound technique to explore how things work so you can understand them, you
will be able to determine if the advice of yesterday is still valid today. You’ll also learn how to
bust “myths,” those “we just know it must be true” adages that we run into every day.
The design you implement to build your applications will ensure either success or failure, and
the knowledge of the fundamentals that this book provides will hopefully allow you to
confidently predict that outcome before it actually happens.
Now, back to working on the next edition—revising the details, but not the core!
Best,
Tom Kyte