1. Trang chủ
  2. » Công Nghệ Thông Tin

Troubleshooting oracle performance, 2nd edition

718 256 0

Đang tải... (xem toàn văn)

Tài liệu hạn chế xem trước, để xem đầy đủ mời bạn chọn Tải xuống

THÔNG TIN TÀI LIỆU

Thông tin cơ bản

Định dạng
Số trang 718
Dung lượng 9,88 MB

Nội dung

Troubleshooting Oracle Performance, 2nd Edition is your systematic guide to diagnosing and resolving performance problems in databasebacked applications involving Oracle’s database engine. Christian Antognini brings a decade and a half experience to his topic. His first edition is one of the most wellrespected books in its field. This second edition has been rigorously updated to cover the latest developments in Oracle Database 11g Release 2 through Oracle Database 12c.What do you do when your database application isn’t running fast enough? You troubleshoot, of course. Finding the slow part of an application is often the easy part of the battle. It’s finding a solution that’s difficult. Troubleshooting Oracle Performance, 2nd Edition helps by providing a systematic approach to addressing the underlying causes of poor database application performance.

www.allitebooks.com For your convenience Apress has placed some of the front matter material after the index Please use the Bookmarks and Contents at a Glance links to access them www.allitebooks.com Contents at a Glance Foreword by Jonathan Lewis�������������������������������������������������������������������������������������������� xix Foreword by Cary Millsap�������������������������������������������������������������������������������������������������� xxi Foreword from the First Edition��������������������������������������������������������������������������������������� xxiii About the Author�������������������������������������������������������������������������������������������������������������� xxv About the Technical Reviewers�������������������������������������������������������������������������������������� xxvii Acknowledgments����������������������������������������������������������������������������������������������������������� xxix Acknowledgments from the First Edition������������������������������������������������������������������������ xxxi Introduction������������������������������������������������������������������������������������������������������������������� xxxiii ■■Part I: Foundations��������������������������������������������������������������������������������������� ■■Chapter 1: Performance Problems������������������������������������������������������������������������������������3 ■■Chapter 2: Key Concepts�������������������������������������������������������������������������������������������������19 ■■Part II: Identification����������������������������������������������������������������������������������� 49 ■■Chapter 3: Analysis of Reproducible Problems���������������������������������������������������������������51 ■■Chapter 4: Real-Time Analysis of Irreproducible Problems������������������������������������������103 ■■Chapter 5: Postmortem Analysis of Irreproducible Problems���������������������������������������151 ■■Part III: Query Optimizer��������������������������������������������������������������������������� 167 ■■Chapter 6: Introducing the Query Optimizer������������������������������������������������������������������169 ■■Chapter 7: System Statistics�����������������������������������������������������������������������������������������191 ■■Chapter 8: Object Statistics�������������������������������������������������������������������������������������������207 v www.allitebooks.com ■ Contents at a Glance ■■Chapter 9: Configuring the Query Optimizer������������������������������������������������������������������273 ■■Chapter 10: Execution Plans������������������������������������������������������������������������������������������299 ■■Part IV: Optimization�������������������������������������������������������������������������������� 357 ■■Chapter 11: SQL Optimization Techniques���������������������������������������������������������������������359 ■■Chapter 12: Parsing�������������������������������������������������������������������������������������������������������419 ■■Chapter 13: Optimizing Data Access�����������������������������������������������������������������������������449 ■■Chapter 14: Optimizing Joins����������������������������������������������������������������������������������������529 ■■Chapter 15: Beyond Data Access and Join Optimization�����������������������������������������������575 ■■Chapter 16: Optimizing the Physical Design�����������������������������������������������������������������655 ■■Part V: Appendix��������������������������������������������������������������������������������������� 679 ■■Bibliography������������������������������������������������������������������������������������������������������������������681 Index���������������������������������������������������������������������������������������������������������������������������������687 vi www.allitebooks.com   About IOUG Press IOUG Press is a joint effort by the Independent Oracle Users Group (the IOUG) and Apress to deliver some of the highest-quality content possible on Oracle Database and related topics The IOUG is the world's leading, independent organization for professional users of Oracle products Apress is a leading, independent technical publisher known for developing high-quality, no-fluff content for serious technology professionals The IOUG and Apress have joined forces in IOUG Press to provide the best content and publishing opportunities to working professionals who use Oracle products Our shared goals include:     Developing content with excellence Helping working professionals to succeed Providing authoring and reviewing opportunities Networking and raising the profiles of authors and readers To learn more about Apress, visit our website at www.apress.com Follow the link for IOUG Press to see the great content that is now available on a wide range of topics that matter to those in Oracle's technology sphere Visit www.ioug.org to learn more about the Independent Oracle Users Group and its mission Consider joining if you haven't already Review the many benefits at www.ioug.org/join Become a member Get involved with peers Boost your career     www.allitebooks.com Introduction Oracle Database has become a huge piece of software This not only means that a single human can no longer be proficient in using all the features provided in recent versions, it also means that some features will rarely be used Actually, in most situations, it’s enough to know and take advantage of a limited number of core features in order to use Oracle Database efficiently and successfully This is precisely why this book covers only the features that, based on my experience, are necessary to troubleshoot most of the database-related performance problems you will encounter The Structure of This Book This book is divided into four parts: Part covers some basics that are required to read the rest of the book Chapter 1, “Performance Problems,” explains not only why it’s essential to approach performance problems at the right moment and in a methodological way, but also why understanding business needs and problems is essential It also describes the most common database-related design problems that lead to suboptimal performance Chapter 2, “Key Concepts,” describes the operations carried out by the database engine when parsing and executing SQL statements and how to instrument application code and database calls It also introduces some important terms that are frequently used in the book Part explains how to approach performance problems in an environment that uses Oracle Database Chapter 3, “Analysis of Reproducible Problems,” describes how to identify performance problems with the help of SQL trace and PL/SQL profilers Chapter 4, “Real-time Analysis of Irreproducible Problems,” describes how to take advantage of information provided by dynamic performance views Several tools and techniques that can be used with them are also introduced Chapter 5, “Postmortem Analysis of Irreproducible Problems,” describes how to analyze performance problems that happened in the past with the help of Automatic Workload Repository and Statspack Part describes the component that is responsible for turning SQL statements into execution plans: the query optimizer Chapter 6, “Introducing the Query Optimizer,” provides an overview of what the query optimizer does and how it does it Chapters and 8, “System Statistics” and “Object Statistics,” describe what system statistics and object statistics are, how to gather them, and why they are important for the query optimizer Chapter 9, “Configuring the Query Optimizer,” covers a configuration road map that you can use to find a good configuration for the query optimizer Chapter 10, “Execution Plans,” describes in detail how to obtain, interpret, and judge the efficiency of execution plans xxxiii www.allitebooks.com ■ Introduction Part shows which features are provided by Oracle Database to execute SQL statements efficiently Chapter 11, “SQL Optimization Techniques,” describes the techniques provided by Oracle Database to influence the execution plans that are generated by the query optimizer Chapter 12, “Parsing,” describes how to identify, solve, and work around performance problems caused by parsing Chapter 13, “Optimizing Data Access,” describes the methods available to access data and how to choose between them Chapter 14, “Optimizing Joins,” discusses how to join several sets of data together efficiently Chapter 15, “Beyond Data Access and Join Optimization,” describes advanced optimization techniques such as parallel processing, materialized views, and result caching And Chapter 16, “Optimizing the Physical Design,” explains why it’s important to optimize the physical design of a database Intended Audience This book is intended for performance analysts, application developers, and database administrators who are involved in troubleshooting performance problems in applications using Oracle Database No specific knowledge in optimization is required However, readers are expected to have a working knowledge of Oracle Database and to be proficient with SQL Some sections of the book cover features that are specific to programming languages such as PL/SQL, Java, C#, PHP, and C These features are covered only to provide a wide range of application developers with specific information about the programming language they’re using You can pick out the ones you’re using or interested in and skip the others Which Versions Are Covered? The most important concepts covered in this book are independent of the version of Oracle Database you’re using It’s inevitable, however, that when details about the implementation are discussed, some information is version-specific This book explicitly discusses the versions currently available from Oracle Database 10g Release to Oracle Database 12c Release They are as follows: • Oracle Database 10g Release 2, up to and including version 10.2.0.5.0 • Oracle Database 11g Release 1, up to and including version 11.1.0.7.0 • Oracle Database 11g Release 2, up to and including version 11.2.0.4.0 • Oracle Database 12c Release 1, version 12.1.0.1.0 Be aware that the granularity is the patch set level, and therefore, changes introduced by security and bundle patches aren’t discussed If the text doesn’t explicitly mention that a feature is available for a specific version only, it’s available for all those versions Online Resources You can download the files referenced through the book from http://top.antognini.ch At the same URL, you will also find addenda and errata as soon as they are available You can also send any type of feedback or questions about the book to top@antognini.ch xxxiv www.allitebooks.com ■ Introduction Differences between the First and the Second Editions The main goals set for the revision of the book were the following: • Add content about Oracle Database 11g Release and Oracle Database 12c Release • Remove content about Oracle9i and Oracle Database 10g Release • Add content that was missing in the first edition (for example, features like hierarchical profiler, active session history, AWR, and Statspack) • Add information about PHP in the parts that cover features that are specific to programming languages • Reorganize part of the material for better readability For example, splitting the chapter about system and object statistics in two • Fix errata and generally enhance the text xxxv www.allitebooks.com Part I Foundations Chi non fa e’ fondamenti prima, gli potrebbe una grande virtú farli poi, ancora che si faccino disagio dello architettore e periculo dello edifizio He who has not first laid his foundations may be able with great ability to lay them afterwards, but they will be laid with trouble to the architect and danger to the building.1 —Niccoló Machiavelli, Il principe 1532 Translated by W K Marriott Available at http://www.gutenberg.org/files/1232/1232-h/1232-h.htm www.allitebooks.com Chapter Performance Problems Too often, optimization begins when an application’s development is already finished This is unfortunate because it implies that performance is not as important as other crucial requirements of the application Performance is not merely optional, though; it is a key property of an application Not only does poor performance jeopardize the acceptance of an application, it usually leads to a lower return on investment because of lower productivity of those using it In fact, as shown in several IBM studies from the early 1980s, there is a close relationship between performance and user productivity The studies showed a one-to-one decrease in user think time and error rates as system transaction rates increased This was attributed to a user’s loss of attention because of longer wait times In addition, poorly performing applications lead to higher costs for software, hardware, and maintenance For these reasons, this chapter discusses why it is important to plan performance, which are the most common design mistakes that lead to sub-optimal performance, and how to know when an application is experiencing performance problems Then, the chapter covers how to approach performance problems when they occur Do You Need to Plan Performance? In software engineering, different models are used to manage development projects Whether the model used is a sequential life cycle like a waterfall model or an iterative life cycle like the one used with agile methodologies, an application goes through a number of common phases (see Figure 1-1) These phases may occur once (in the waterfall model) or several times (in the iterative model) in development projects Requirements Analysis Analysis and Design Coding and Unit Testing Integration and Acceptance Testing Figure 1-1.  Essential phases in application development If you think carefully about the tasks to carry out for each of these phases, you may notice that performance is inherent to each of them In spite of this, real development teams quite often forget about performance, at least until performance problems arise At that point, it may be too late Therefore, the following sections cover what you should not forget, from a performance point of view, the next time you are developing an application www.allitebooks.com ■ Contents ■■Chapter 9: Configuring the Query Optimizer������������������������������������������������������������������273 To Configure or Not to Configure ��������������������������������������������������������������������������������������������273 Configuration Road Map������������������������������������������������������������������������������������������������������������274 Set the Right Parameter!�����������������������������������������������������������������������������������������������������������276 Query Optimizer Parameters����������������������������������������������������������������������������������������������������������������������������� 276 PGA Management���������������������������������������������������������������������������������������������������������������������������������������������� 291 On to Chapter 10�����������������������������������������������������������������������������������������������������������������������297 ■■Chapter 10: Execution Plans������������������������������������������������������������������������������������������299 Obtaining Execution Plans���������������������������������������������������������������������������������������������������������299 The EXPLAIN PLAN Statement��������������������������������������������������������������������������������������������������������������������������� 299 Dynamic Performance Views����������������������������������������������������������������������������������������������������������������������������� 303 Automatic Workload Repository and Statspack������������������������������������������������������������������������������������������������� 305 Tracing Facilities������������������������������������������������������������������������������������������������������������������������������������������������ 307 The dbms_xplan Package���������������������������������������������������������������������������������������������������������311 Output���������������������������������������������������������������������������������������������������������������������������������������������������������������� 311 The display Function����������������������������������������������������������������������������������������������������������������������������������������� 316 The display_cursor Function����������������������������������������������������������������������������������������������������������������������������� 322 The display_awr Function��������������������������������������������������������������������������������������������������������������������������������� 323 Interpreting Execution Plans�����������������������������������������������������������������������������������������������������325 Parent-Child Relationship���������������������������������������������������������������������������������������������������������������������������������� 325 Types of Operations������������������������������������������������������������������������������������������������������������������������������������������� 328 Stand-Alone Operations������������������������������������������������������������������������������������������������������������������������������������� 328 Iterative Operations������������������������������������������������������������������������������������������������������������������������������������������� 331 Unrelated-Combine Operations������������������������������������������������������������������������������������������������������������������������� 331 Related-Combine Operations����������������������������������������������������������������������������������������������������������������������������� 333 Divide and Conquer������������������������������������������������������������������������������������������������������������������������������������������� 342 Special Cases���������������������������������������������������������������������������������������������������������������������������������������������������� 345 Adaptive Execution Plans���������������������������������������������������������������������������������������������������������������������������������� 348 xiii ■ Contents Recognizing Inefficient Execution Plans�����������������������������������������������������������������������������������353 Wrong Estimations�������������������������������������������������������������������������������������������������������������������������������������������� 353 Restriction Not Recognized������������������������������������������������������������������������������������������������������������������������������� 355 On to Part 4�������������������������������������������������������������������������������������������������������������������������������356 ■■Part IV: Optimization�������������������������������������������������������������������������������� 357 ■■Chapter 11: SQL Optimization Techniques���������������������������������������������������������������������359 Altering the Access Structures��������������������������������������������������������������������������������������������������360 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 360 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 361 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 361 Altering the SQL Statement�������������������������������������������������������������������������������������������������������361 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 361 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 363 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 363 Hints������������������������������������������������������������������������������������������������������������������������������������������363 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 363 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 370 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 370 Altering the Execution Environment������������������������������������������������������������������������������������������372 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 372 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 375 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 375 Stored Outlines��������������������������������������������������������������������������������������������������������������������������375 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 375 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 385 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 385 SQL Profiles�������������������������������������������������������������������������������������������������������������������������������387 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 387 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 401 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 402 xiv ■ Contents SQL Plan Management��������������������������������������������������������������������������������������������������������������402 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 403 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 417 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 417 On to Chapter 12�����������������������������������������������������������������������������������������������������������������������418 ■■Chapter 12: Parsing�������������������������������������������������������������������������������������������������������419 Identifying Parsing Problems����������������������������������������������������������������������������������������������������419 Quick Parses������������������������������������������������������������������������������������������������������������������������������������������������������ 420 Long Parses������������������������������������������������������������������������������������������������������������������������������������������������������� 425 Solving Parsing Problems���������������������������������������������������������������������������������������������������������427 Quick Parses������������������������������������������������������������������������������������������������������������������������������������������������������ 427 Long Parses������������������������������������������������������������������������������������������������������������������������������������������������������� 433 Working Around Parsing Problems��������������������������������������������������������������������������������������������433 Cursor Sharing��������������������������������������������������������������������������������������������������������������������������������������������������� 434 Server-Side Statement Caching������������������������������������������������������������������������������������������������������������������������ 436 Using Application Programming Interfaces�������������������������������������������������������������������������������438 PL/SQL��������������������������������������������������������������������������������������������������������������������������������������������������������������� 439 OCI��������������������������������������������������������������������������������������������������������������������������������������������������������������������� 442 JDBC������������������������������������������������������������������������������������������������������������������������������������������������������������������ 443 ODP.NET������������������������������������������������������������������������������������������������������������������������������������������������������������� 445 PHP�������������������������������������������������������������������������������������������������������������������������������������������������������������������� 446 On to Chapter 13�����������������������������������������������������������������������������������������������������������������������447 ■■Chapter 13: Optimizing Data Access�����������������������������������������������������������������������������449 Identifying Suboptimal Access Paths����������������������������������������������������������������������������������������449 Identification������������������������������������������������������������������������������������������������������������������������������������������������������ 449 Pitfalls���������������������������������������������������������������������������������������������������������������������������������������������������������������� 452 Causes��������������������������������������������������������������������������������������������������������������������������������������������������������������� 454 Solutions������������������������������������������������������������������������������������������������������������������������������������������������������������ 454 xv ■ Contents SQL Statements with Weak Selectivity�������������������������������������������������������������������������������������459 Full Table Scans������������������������������������������������������������������������������������������������������������������������������������������������� 459 Full Partition Scans�������������������������������������������������������������������������������������������������������������������������������������������� 461 Range Partitioning��������������������������������������������������������������������������������������������������������������������������������������������� 461 Hash and List Partitioning��������������������������������������������������������������������������������������������������������������������������������� 474 Composite Partitioning�������������������������������������������������������������������������������������������������������������������������������������� 475 Design Considerations��������������������������������������������������������������������������������������������������������������������������������������� 477 Full Index Scans������������������������������������������������������������������������������������������������������������������������������������������������ 479 SQL Statements with Strong Selectivity������������������������������������������������������������������������������������482 Rowid Access���������������������������������������������������������������������������������������������������������������������������������������������������� 482 Index Access������������������������������������������������������������������������������������������������������������������������������������������������������ 484 Single-table Hash Cluster Access���������������������������������������������������������������������������������������������������������������������� 526 On to Chapter 14�����������������������������������������������������������������������������������������������������������������������528 ■■Chapter 14: Optimizing Joins����������������������������������������������������������������������������������������529 Definitions���������������������������������������������������������������������������������������������������������������������������������529 Join Trees���������������������������������������������������������������������������������������������������������������������������������������������������������� 529 Types of Joins���������������������������������������������������������������������������������������������������������������������������������������������������� 534 Restrictions vs Join Conditions������������������������������������������������������������������������������������������������������������������������ 537 Nested Loops Joins�������������������������������������������������������������������������������������������������������������������538 Concept������������������������������������������������������������������������������������������������������������������������������������������������������������� 538 Two-Table Join��������������������������������������������������������������������������������������������������������������������������������������������������� 539 Four-Table Join�������������������������������������������������������������������������������������������������������������������������������������������������� 541 Buffer Cache Prefetches������������������������������������������������������������������������������������������������������������������������������������ 542 Merge Joins�������������������������������������������������������������������������������������������������������������������������������544 Concept������������������������������������������������������������������������������������������������������������������������������������������������������������� 544 Two-Table Join��������������������������������������������������������������������������������������������������������������������������������������������������� 545 Four-Table Join�������������������������������������������������������������������������������������������������������������������������������������������������� 548 Work Areas�������������������������������������������������������������������������������������������������������������������������������������������������������� 549 Hash Joins���������������������������������������������������������������������������������������������������������������������������������555 Concept������������������������������������������������������������������������������������������������������������������������������������������������������������� 555 Two-table Joins������������������������������������������������������������������������������������������������������������������������������������������������� 556 xvi ■ Contents Four-Table Joins������������������������������������������������������������������������������������������������������������������������������������������������ 557 Work Areas�������������������������������������������������������������������������������������������������������������������������������������������������������� 559 Index Joins�������������������������������������������������������������������������������������������������������������������������������������������������������� 560 Outer Joins��������������������������������������������������������������������������������������������������������������������������������561 Choosing the Join Method���������������������������������������������������������������������������������������������������������562 First-Rows Optimization������������������������������������������������������������������������������������������������������������������������������������ 562 All-Rows Optimization��������������������������������������������������������������������������������������������������������������������������������������� 562 Supported Join Methods����������������������������������������������������������������������������������������������������������������������������������� 562 Parallel Joins����������������������������������������������������������������������������������������������������������������������������������������������������� 563 Partition-wise Joins������������������������������������������������������������������������������������������������������������������563 Full Partition-wise Joins������������������������������������������������������������������������������������������������������������������������������������ 563 Partial Partition-wise Joins������������������������������������������������������������������������������������������������������������������������������� 566 Star Transformation�������������������������������������������������������������������������������������������������������������������568 On to Chapter 15�����������������������������������������������������������������������������������������������������������������������574 ■■Chapter 15: Beyond Data Access and Join Optimization�����������������������������������������������575 Materialized View����������������������������������������������������������������������������������������������������������������������575 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 576 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 596 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 596 Result Caching��������������������������������������������������������������������������������������������������������������������������597 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 597 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 604 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 604 Parallel Processing��������������������������������������������������������������������������������������������������������������������605 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 605 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 636 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 636 Direct-Path Insert����������������������������������������������������������������������������������������������������������������������641 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 641 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 644 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 644 xvii ■ Contents Row Prefetching������������������������������������������������������������������������������������������������������������������������645 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 645 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 650 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 650 Array Interface���������������������������������������������������������������������������������������������������������������������������650 How It Works������������������������������������������������������������������������������������������������������������������������������������������������������ 650 When to Use It��������������������������������������������������������������������������������������������������������������������������������������������������� 654 Pitfalls and Fallacies������������������������������������������������������������������������������������������������������������������������������������������ 654 On to Chapter 16�����������������������������������������������������������������������������������������������������������������������654 ■■Chapter 16: Optimizing the Physical Design�����������������������������������������������������������������655 Optimal Column Order���������������������������������������������������������������������������������������������������������������655 Optimal Datatype�����������������������������������������������������������������������������������������������������������������������657 Pitfalls in Datatype Selection����������������������������������������������������������������������������������������������������������������������������� 657 Best Practices in Datatype Selection����������������������������������������������������������������������������������������������������������������� 660 Row Migration and Row Chaining���������������������������������������������������������������������������������������������662 Migration vs Chaining��������������������������������������������������������������������������������������������������������������������������������������� 662 Problem Description������������������������������������������������������������������������������������������������������������������������������������������ 664 Problem Identification��������������������������������������������������������������������������������������������������������������������������������������� 664 Solutions������������������������������������������������������������������������������������������������������������������������������������������������������������ 665 Block Contention�����������������������������������������������������������������������������������������������������������������������665 Problem Description������������������������������������������������������������������������������������������������������������������������������������������ 666 Problem Identification��������������������������������������������������������������������������������������������������������������������������������������� 666 Solutions������������������������������������������������������������������������������������������������������������������������������������������������������������ 670 Data Compression���������������������������������������������������������������������������������������������������������������������673 Concept������������������������������������������������������������������������������������������������������������������������������������������������������������� 673 Requirements���������������������������������������������������������������������������������������������������������������������������������������������������� 675 Methods������������������������������������������������������������������������������������������������������������������������������������������������������������� 675 ■■Part V: Appendix��������������������������������������������������������������������������������������� 679 ■■Bibliography������������������������������������������������������������������������������������������������������������������681 Index���������������������������������������������������������������������������������������������������������������������������������687 xviii Foreword by Jonathan Lewis When I sat down to write this foreword for the Second Edition of Troubleshooting Oracle Performance (TOP), the first thing I did, after reading the draft chapters, was go back to the foreword I wrote for the first edition to see how much it needed changing Obviously, there were references to chapter numbers that needed to change, but to my great surprise I discovered that I had failed to make a couple of important points about why this book should be required reading for all aspiring Oracle professionals Being allowed to revise the foreword allows me to address those points The Internet carries a lot of information about Oracle, but it’s highly fragmented and desperately in need of collation and cohesion In fact, many of the books published about Oracle suffer from the same problem—they collect many bits of information together but don’t supply any form of cohesive narrative that would allow the reader to grasp a topic in a way that can become a launching point for subsequent learning and understanding Even the Oracle manuals suffer from the same problem (though to a lesser degree) I’ve often made the point in my presentations on troubleshooting that your reading should include key manuals from Oracle’s documentation set – the Oracle Database Concepts manual, the Oracle Database Administrator’s Guide, and the Oracle Database Performance Tuning Guide – and that there will be things in any one of those manuals that you won’t really understand until you read the other two A key feature of TOP is the way it structures the information to avoid the historical problem—it tells us what we are trying to achieve, why we want to achieve it, and then how to achieve it Sometimes this structure is astonishing in its simplicity I was particularly struck at one point by the titles of three consecutive chapters Ignore, for the moment, that the content of the chapters was well worth reading The titles alone were a startlingly clear presentation of a concept that rarely gets recognized as the first question of troubleshooting: • Chapter 3: Analysis of Reproducible Problems • Chapter 4: Real-time Analysis of Irreproducible Problems • Chapter 5: Postmortem Analysis of Irreproducible Problems Did you realize that there are only three types of problems, and the strategy you use to solve a problem depends on which of the three classes it belongs to? The fundamental source of the data you can use to solve the problem is the same in all cases, but the availability and granularity of some of that data changes over time Recognizing this grouping is the first step in a methodical approach to solving problems This pattern of collating bits of information and presenting a cohesive picture of what’s possible and how to achieve results runs through the whole book Chapter 6, for example, pulls together a long list of the transformations that Oracle can perform when optimizing a query; Chapter 13 gives a surprisingly long list of all the different ways in which partition-based operations can appear in execution plans By the time you’ve finished reading this book, you will probably find that you already knew a lot more than you realized, but you will also have learned a lot more about what you knew because all the pieces have been pulled together, the gaps have been filled, and the information has been restructured through Christian’s knowledge and insights —Jonathan Lewis Jonathan Lewis is well known in the Oracle world He has worked with the Oracle RDBMS for more than 26 years, written three books about it (two published by Apress), and traveled to more than 50 different countries to supply his skills at troubleshooting, tuning, and design He is based in the UK, conveniently close to two major airports and one international train station xix Foreword by Cary Millsap I think the best thing that has happened to Oracle performance in the past ten years is the radical improvement in the quality of the information you can buy now at the bookstore In the old days, the books you bought about Oracle performance all looked pretty much the same They insinuated that your Oracle system inevitably suffered from too much I/O (which is, in fact, not inevitable) or not enough memory (which they claimed was the same thing as too much I/O, which also isn’t true) They’d showed you loads and loads of SQL scripts that you might run, and they’d tell you to tune your SQL And that, they said, would fix everything It was an age of darkness Chris’s book is a member of the family tree that has brought to us . . .  light The difference between the darkness and the light boils down to one simple concept It’s a concept that your mathematics teachers made you execute from the time when you were about ten years old: show your work I don’t mean “show and tell,” where someone claims he has improved performance at hundreds of customer sites by hundreds of percentage points [sic], so therefore he’s an expert I mean show your work, which means documenting a relevant baseline measurement, conducting a controlled experiment, documenting a second relevant measurement, and then showing your results openly and transparently so that your reader can follow along and even reproduce your test if desired That’s a big deal When authors started doing that, Oracle audiences started getting a lot smarter Since 2000, there has been a dramatic increase in the number of people in the Oracle community who ask intelligent questions and demand intelligent answers about performance And there’s been acceleration in the drowning-out of some really bad ideas that lots of people used to believe In this book, Chris follows the pattern that works He tells you useful things But he doesn’t stop there He shows you how he knows, which is to say he shows you how you can find out for yourself He shows his work That brings you two big benefits First, showing his work helps you understand more deeply what he’s showing you, which makes his lessons easier for you to remember and apply Second, by understanding his examples, you can not only understand the things Chris is showing you, you’ll also be able to answer additional good questions that Chris hasn’t covered—like what will happen in the next release of Oracle after this book has gone to print This book, for me, is both a technical and a “persuasional” reference It contains tremendous amounts of fully documented homework that I can reuse It also contains eloquent new arguments on several points about which I share Chris’s views and his passion The arguments that Chris uses in this book will help me convince more people to the Right Things Chris is a smart, energetic guy who stands on the shoulders of Dave Ensor, Lex de Haan, Anjo Kolk, Steve Adams, Jonathan Lewis, Tom Kyte, and a handful of other people I regard as heroes for bringing rigor to our field Now we have Chris’s shoulders to stand on as well —Cary Millsap Cary Millsap is chief executive of Method R Corporation, a software performance company He wrote Optimizing Oracle Performance with Jeff Holt in 2003, which earned Cary and Jeff the Oracle Magazine 2004 Author of the Year award Cary is also the author of The Method R Guide to Mastering Oracle Trace Data You can find Cary at http://method-r.com and http://carymillsap.blogspot.com xxi Foreword from the First Edition I started using the Oracle RDBMS a little over 20 years ago, and it took about three years for me to discover that troubleshooting and tuning had acquired a reputation verging on the mystical One of the developers had passed a query to the DBA group because it wasn’t performing well I checked the execution plan, checked the data patterns, and pointed out that most of the work could be eliminated by adding an index to one of the tables The developer’s response was: “But it doesn’t need an index, it’s a small table.” (This was in the days of 6.0.36, by the way, when the definition of a “short” table was “no more than four blocks long”) So I created the index anyway, and the query ran about 30 times faster—and then I had a lot of explaining to Troubleshooting does not depend on magic, mystique, or myth; it depends on understanding, observation, and interpretation As Richard Feynmann once said, “It doesn’t matter how beautiful your theory is; it doesn’t matter how smart you are; if you theory doesn’t agree with experiment, it’s wrong.” There are many “theories” of Oracle performance that are wrong and that should have been deleted from the collective memory many years ago—and Christian Antognini is one of the people helping to wipe them out In this book, Christian sets out to describe how things really work, what types of symptoms you should be watching out for, and what those symptoms mean Above all, he encourages you to be methodical and stick to the relevant details in your observation and analysis Armed with this advice, you should be able to recognize the real issues when performance problems appear and deal with them in the most appropriate way Although this is a book that should probably be read carefully from cover to cover, I think different readers will benefit from it in different ways Some may pick out the occasional special insight while browsing, as I did in Chapter with the explanation of height-balanced histograms—after years of trying to find an intuitively clear reason for the name, Christian’s description suddenly made it blatantly obvious Some readers may find short descriptions of features that help them understand why Oracle has implemented that feature and allow them to extrapolate from the examples to situations which are relevant in their applications The description of “secure view merging” in Chapter was one such description for me Other readers may find that they reread a section of the book time and again because it covers so many details of some particularly important and relevant feature they are using I’m sure that the extensive discussion of partitioning in Chapter is something that many people will return to again and again There’s a lot in this book—and it’s all worth reading Thank you, Christian —Jonathan Lewis xxiii About the Author Since 1995, Christian Antognini has focused on understanding how Oracle Database works His main interests include logical and physical database design, the query optimizer, and basically everything else related to application performance management He is currently working as a senior principal consultant and trainer at Trivadis (www.trivadis.com) in Zürich, Switzerland If Christian is not helping one of his customers get the most out of Oracle, he is somewhere lecturing on application performance management or new Oracle Database features for developers In addition to classes and seminars organized by Trivadis, he regularly presents at conferences and user-group meetings He is a proud member of the OakTable Network and an Oracle ACE Director Christian lives in Ticino, Switzerland, with his wife, Michelle, and their two children, Sofia and Elia He spends a great deal of his spare time with his wonderful family and, whenever possible, reading books, watching tennis, enjoying a good movie, riding one of his bicycles, or gliding down the Swiss alps on a snowboard xxv About the Technical Reviewers Alberto Dell’Era has been a full-time Oracle Database consultant since 1999, shortly after graduating summa cum laude in electronics engineering He currently works for NTT DATA in Italy (a global innovation partner with headquarters in Tokyo and business operations in over 40 countries), where, as an architect, SME, performance tuner, mentor, and sometimes teacher, he helps colleagues and customers to get the most out of Oracle He especially loves getting his hands dirty working on the development of some critical software module He is a member of the OakTable Network (www.oaktable.net), the well-known organization of Oracle professionals that approaches Oracle the same way the scientific community approaches the world: by careful study and practical experimentation, and by sharing results in reproducible means (scripts, prototypes, and so forth) so they can be peer-reviewed easily He strongly believes that knowing how a product really works internally is both fun and the key to being really effective in professional life For this reason, he spends a lot of time and effort reading technical papers, books and blog posts, and making his own investigations, prototypes, and more He owns www.adellera.it and can be contacted at alberto.dellera@gmail.com Francesco Renne was born in 1962 in Como, Italy He studied computer science at the University of Milan and after graduating, joined Olivetti, where he worked on the development of the Unix operating system Francesco has been interested in performance since the beginning of his professional career He has worked on Unix internals and the Oracle environment to achieve the best possible performance in different environments (new products, benchmarks, international real applications on production, and so on) In 1994, he joined the Banca Popolare di Bergamo, the only bank in Italy that has rewritten its entire information system using Unix and Oracle He has made major contributions to improving performance over the whole platform In 1999, he co-founded ICTeam and is now that company’s CEO He continues to work on performance, especially on Oracle Data Warehouse environments, for some of the largest companies in Italy Francesco lives near Bergamo, Italy, with his wife, Adria, and their two daughters, Viola and Veronica When not striving to improve something, he enjoys staying with his family, listening to progressive music, and taking pictures xxvii ■ About the Technical Reviewers Jože Senegacnik has more than 25 years’ experience in working with Oracle products In 1988, he started working with Oracle version Since 1992, he has been self-employed as a private researcher in the field of computer science Most of his work time is dedicated to solving performance bottlenecks in different application solutions that are based on the Oracle database He is also an international speaker, giving talks on the most important Oracle database–related events worldwide He conducts well-known performance tuning courses together with Oracle University xxviii Acknowledgments Let’s face it, writing a book isn’t a rewarding task At all! It takes a huge amount of your free time, that you could spend doing something way more interesting So, while deciding whether I should embark on the project of writing the second edition of Troubleshooting Oracle Performance, I asked myself several times, why should I it? In the end, the most important factor was the hundreds positive messages I received since I published the first edition in 2008 I discovered that publishing a book that other people regard as useful is rewarding! For that reason, the first big thank you goes to all the readers of the first edition who gave me feedback Without the motivation you gave me, this second edition wouldn’t exist Motivation isn’t the only thing you need to write a book As already mentioned, lots of time is involved In that respect, I’m privileged to work for a company that, since 1999, when I started there, gave me all the support I needed not only to develop my skills, but also to pursue ideas (like writing a book) that weren’t always self-evident So, the second belated thank you goes to Trivadis When you concentrate on writing a piece of text over an extended period of time, sometimes you miss or forget obvious things Because of that, I’d say it’s of paramount importance to be surrounded by people who check what you’re doing Great thanks go to the technical reviewers Alberto, Franco, and Jože You helped me improve the quality of the book considerably Any remaining errors are, of course, my own responsibility In addition to the “official” technical reviewers, I would also like to thank Dani Schnider, Franck Pachot, Randolf Geist, and Tony Hasler for reading selected parts of the book and providing me with their comments on and impressions of the text I also have to thank the people at Apress for supporting me during the development of the book In particular, Jonathan Gennick, who believed it made sense to publish a second edition of Troubleshooting Oracle Performance As with the first edition, another person who played a central role was Curtis Gautschi In fact, he assisted me by proofreading the book once again And that, even though he doesn’t understand most of the things he reads (according to him) Thank you so much, Curtis, for assisting me all these years now Finally, special thanks go to Jonathan and Cary for endorsing this book by writing a foreword You inspired me so much at the beginning of my career, and now I hope a book like this one can inspire more people in the Oracle community to the right thing xxix Acknowledgments from the First Edition Many people assisted me in writing the book you now have in your hands I’m extremely grateful to all of them Without their assistance, this piece of work wouldn’t have seen the light of the day While sharing with you the brief history of TOP (Troubleshooting Oracle Performance), let me thank the people who made it all possible Though I didn’t realize it at the time, this story began on July 16, 2004, the day of the kickoff meeting I had organized for a new seminar, Oracle Optimization Solutions, which I had planned to write with some colleagues of mine at Trivadis During the meeting, we discussed the objectives and structure of the seminar Many of the ideas developed that day and while writing the seminar in the months afterward have been reused in this book Big thanks to Arturo Guadagnin, Dominique Duay, and Peter Welker for their collaboration back then Together, we wrote what, I’m convinced to this day, was an excellent seminar In addition to them, I also have to thank Guido Schmutz He participated in the kickoff meeting only, but strongly influenced the way we approached the subjects covered in the seminar Two years later, in the spring of 2006, I started thinking seriously about writing this book I decided to contact Jonathan Gennick at Apress to ask for his opinion about what I had in mind From the beginning, he was interested in my proposal, and as a result, a few months later I decided to write the book for Apress Thank you, Jonathan, for supporting me from the very beginning In addition, thanks to all the people at Apress who worked on the book I only had the pleasure of working with Sofia Marchant, Kim Wimpsett, and Laura Esterman, but I know that several others contributed to it as well Having an idea and a publisher are not enough to write a book You also need time, a lot of time Fortunately, the company I work for, Trivadis, was able to support me and the project in this way Special thanks to Urban Lankes and Valentin De Martin In order to write a book, it’s also essential to be surrounded by people who carefully check what you’re writing Great thanks go to the technical reviewers, Alberto Dell’Era, Francesco Renne, Jože Senegacnik, and Urs Meier They helped me considerably in improving the quality of the book Any remaining errors are, of course, my own responsibility In addition to the technical reviewers, I would also like to thank Daniel Rey, Peter Welker, Philipp von dem Bussche-Hünnefeld, and Rainer Hartwig for reading parts of the book and providing me with their comments on and impressions of the text Another person who played a central role is Curtis Gautschi For many years, he has proofread and enhanced my poor English Thank you so much, Curtis, for assisting me for so many years now I know—I should really try to improve my English skills someday Unfortunately, I find it much more interesting (and easier) to improve the performance of Oracle-based applications than my command of foreign languages Special thanks also go to Cary Millsap and Jonathan Lewis for writing the forewords I know that you spent a considerable amount of your valuable time writing them I’m very much indebted to you both for that Another special thank goes to Grady Booch for giving me the permission to reproduce the cartoon in Chapter Finally, I would like to thank all the companies for which I have had the privilege to consult over the years, all those who have attended my classes and seminars and asked so many good questions, and all the Trivadis consultants for sharing their knowledge I have learned so much from all of you xxxi ... currently available from Oracle Database 10g Release to Oracle Database 12c Release They are as follows: • Oracle Database 10g Release 2, up to and including version 10.2.0.5.0 • Oracle Database 11g... Second Editions The main goals set for the revision of the book were the following: • Add content about Oracle Database 11g Release and Oracle Database 12c Release • Remove content about Oracle9 i... in troubleshooting performance problems in applications using Oracle Database No specific knowledge in optimization is required However, readers are expected to have a working knowledge of Oracle

Ngày đăng: 15/08/2018, 11:00

TỪ KHÓA LIÊN QUAN

w