Home
Home 		Customize
Customize		 Help
Help 		Contact us
Contact Us

Virtual Book about 'design'


Table of Contents: Virtual Book about 'design'

This virtual book brings together the most relevant topics about 'design'. The topics are grouped into these categories:
[Back to top]

Introductory Information about 'design'

This category includes definitions, overviews, concepts, restrictions, frequently asked questions, and explanations of how things work. This is where you should start if you are not familiar with this subject area.

Results in this section come from these books:

[ Next book ]

Designing and Tuning for Performance

Overview of Diagnostic Tools

Understanding EXPLAIN PLAN

EXPLAIN PLAN Restrictions

Understanding SQL Trace and TKPROF

Introduction to Oracle Trace

Understanding CPU Problems

Solving CPU Problems by Changing System Architectures

Understanding Memory Allocation Issues

Understanding Oracle Performance Tuning

What Is Performance Tuning?

Understanding I/O Problems

Understanding Contention Issues

Understanding Connection Models

Understanding Operating System Performance Issues

Understanding Instance Recovery

Understanding Hints

SQL Processing Architecture

What Is The Optimizer?

Choosing an Optimizer Approach and Goal

Overview of Optimizer Operations

Introduction to Tuning

Understanding Statistics

[ Previous book | Next book ]

Application Developer's Guide - Object-Relational Features

What are the design goals of Oracle8i Object-Relational & Extensibility technologies?

[ Previous book | Next book ]

Applications InterConnect User's Guide

Design Time Concepts and iStudio

[ Previous book | Next book ]

Data Warehousing Guide

Overview of Logical Design

Schema Design Guidelines for Materialized Views

Overview of Physical Design

[ Previous book | Next book ]

Integration Server Overview

Oracle Integration Server Design Objectives

[Back to top]

Tasks Related to 'design'

This category includes how-to information, both detailed procedures and general usage information and guidelines. The tasks are listed alphabetically, with shortcut links that jump to places within the list. For example, if you want to find Creating, look for a link labeled CRE.

Shortcuts to Tasks

ACC ADD ADJ ALL ANA APP ASS AVO BAC CAC CAL CHA CHE CHO COL
COM CON CRE DEC DEF DES DET DIA DIS EDI ENA EST EVA EXA FIN
FIT FOR GAT GEN GET HAN HOW IDE IMP INC IND KEE LIM LOA LOC
MAN MAT MEA MER MIS MOD MON MOV OPE OPT PAG PLA PRE PRU PUS
QUE RE- REA REC RED REG REM REP RES SCH SEL SEP SET SIZ SOL
SOR SPE SPR STO STR TES TRA TUN UND UPG USI VER VIE WRI

Accessing Collected Data

Accessing the View's Rows with the Original Statement

Accommodating LOBs in the Buffer Cache

Adding Dispatcher Processes

Adding More Free Lists

Adjusting Checkpointing Activity

Adjusting Recovery Time: Example Scenario

Adjusting Session Data Unit Buffer Size

Allocating Additional Memory for the Library Cache

Allocating Adequate Memory to Individual Users

Allocating Channels

Allocating Disk Buffers

Allocating Extents

Allocating Input Files

Allocating Tape Buffers

Analyzing I/O Requirements

Analyzing Object Statistics

Analyzing V$DISPATCHER_RATE Statistics

Applying an Aggregate Function to the View

Applying an Object-Relational Design to the Application

Applying the Tuning Method

Assessing the Value of Indexes

Avoiding Balloon Tactic for Coding SQL

Avoiding Complex Expressions

Avoiding Dynamic Space Management

Avoiding Dynamic Space Management in Rollback Segments

Avoiding Pitfalls in TKPROF Interpretation

Avoiding Rule-Based Optimizer Techniques

Backing Up Empty Files or Files with Few Changes

Backing Up Full Files

Caching Session Cursors

Calculating Performance Overhead

Calculating Performance Overhead: Example Scenario

Calculating the Cache Hit Ratio

Changing the Goal with Hints

Checking for the Correct Number of Dedicated Pre-Spawn Servers

Checking Oracle Datafile I/O with V$FILESTAT

Checking Oracle I/O Utilization

Checking System I/O Utilization

Checking the Connect/Second Rate

Checking the Connections

Choosing an Optimizer Approach and Goal

Choosing Columns and Expressions to Index

Choosing Composite Indexes

Choosing Data Block Size

Choosing Execution Plans for Join Statements

Choosing Execution Plans for Joins with the CBO

Choosing Execution Plans for Joins with the RBO

Choosing the Number of Buckets for a Histogram

Collecting Event Data

Compacting Indexes

Comparing SQL Statements and PL/SQL Blocks

Configuring the Initialization Parameter File

Configuring the Large Pool

Controlling Space Reclamation of the Shared Pool

Creating Bitmap Indexes

Creating Hash Clusters

Creating Histograms

Creating Lists of Tables with Stale or No Statistics

Creating Outlines

Creating Rollback Segments

Creating the Output Table

Deciding When to Use Discrete Transactions

Deciding Which Statements to Tune

Defining New Buffer Pools

Designating Tables for Monitoring and Automated Statistics Gathering

Designing Applications

Designing Applications

Designing CHECK Constraints

Designing for Survivability

Designing for Survivability

Designing Indexes

Designing Management Applications Based on Oracle MIBs

Designing Operators

Designing Tables

Designing the Database

Designing the types

Designing Triggers

Designing WebDB Sites

Detecting and Solving CPU Problems

Detecting Contention for Redo Log Buffer Latches

Detecting Contention for Space in the Redo Log Buffer

Detecting Contention Problems

Detecting Dynamic Extension

Detecting I/O Problems

Detecting Memory Allocation Problems

Detecting Network Problems

Detecting Operating System Problems

Determining an Effective Setting for MTS UGA Storage

Determining If Tape is Streaming for Asynchronous I/O

Determining If Tape is Streaming for Synchronous I/O

Determining if There Enough Physical RAM

Determining the Event Set that Oracle Trace Collects

Determining the Optimal Number of Dispatchers and Shared Servers

Determining the Problem

Determining the Strongest Checkpoint Influence

Determining which Buffers are in the Pool

Diagnosing System Performance Problems

Disallowing Further MTS Use with Concurrent MTS Use

Displaying PLAN_TABLE Output

Displaying Range and Hash Partitioning with EXPLAIN PLAN

Dissecting Bottlenecks

Dissecting the I/O Path

Editing the TKPROF Output SQL Script

Enabling Automated Statistics Gathering

Enabling Connection Concentration

Enabling Connection Pooling

Enabling Multiple Buffer Pools

Enabling Oracle Trace Collections

Enabling Plan Stability

Estimating Bitmap Index Size

Estimating Recovery Time

Estimating the Maximum Number of Dispatcher Processes

Evaluating Buffer Cache Activity with the Cache Hit Ratio

Evaluating Device Bandwidth

Evaluating Multiple Extents

Evaluating Performance

Evaluating the Cache Hit Ratio

Evaluating Unlimited Extents

Examining Busy Rates for Dispatcher Processes

Examining Library Cache Activity

Examining Redo Log Activity

Examining Wait Times for Dispatcher Process Response Queues

Finding Bottlenecks

Finding the Current Value of a Statistic

Finding the Rate of Change of a Statistic

Fitting the System Global Area into Main Memory

Forcing the Join Order

Formatting Oracle Trace Data to Oracle Tables

Gathering Automated Statistics

Gathering Index Statistics

Gathering New Optimizer Statistics

Gathering Statistics

Gathering Statistics with the DBMS_STATS Package

Generating Statistics

Generating the TKPROF Output SQL Script

Getting More Information on a Selected Query

Handling Complex Logic in the Application

How to Use DBMS_SHARED_POOL

Identifying and Eliminating LRU Latch Contention

Identifying Bottlenecks with Asynchronous I/O

Identifying Bottlenecks with Synchronous I/O

Identifying Contention for Dispatcher Processes

Identifying Contention for Parallel Execution Servers

Identifying Contention for Shared Servers

Identifying Contention Using the Dispatcher-Specific Views

Identifying Free List Contention

Identifying Rollback Segment Contention

Identifying Segments to Put into the KEEP and RECYCLE Buffer Pools

Identifying the Required Read/Write Operations

Identifying Unnecessary Parse Calls

Implementing and Tune Your Design

Importing Data Viewer Information into Third-Party Tools

Importing Data Viewer SQL Into Oracle SQL Analyze

Importing Oracle Trace Data into Oracle Expert

Improving Backup Throughput

Increasing SORT_AREA_SIZE to Avoid Sorting to Disk

Increasing the Cache Hit Ratio by Reducing Buffer Cache Misses

Increasing the Maximum Number of Shared Servers

Increasing Throughput to Enable Tape Streaming

Indexing Null Values

Keeping Shared SQL and PL/SQL in the Shared Pool

Keeping Statistics Current and Using Plan Stability to Preserve Execution Plans

Limiting Memory Use Per User Session by Setting PRIVATE_SGA

Loading PL/SQL Objects into the Shared Pool

Locating the Source of Bottlenecks

Managing Collections

Managing Data in the Shared Pool

Managing Shared SQL and PL/SQL Areas

Managing Statistics

Matching SQL Statements with Outlines

Measuring Synchronous and Asynchronous I/O Rates

Merging a View That Has a Single Base Table

Merging the View's Query into the Statement

Missing Statistics

Modeling and Design

Modeling and Design

Modifying or Disabling Triggers

Modifying the SQL.BSQ File

Monitoring Data Dictionary Cache Activity

Monitoring Instance Recovery

Monitoring Progress of Fast-Start Parallel Rollback

Moving from Logical to Physical Design

Moving Outline Tables

Operating System and Hardware Caches

Operating System Resource Managers

Operating System Tools

Optimizing Anti-Joins and Semi-Joins

Optimizing Compound Queries

Optimizing Distributed Statements

Optimizing Heterogeneous Distributed SQL Statements

Optimizing Instance Performance

Optimizing Join Statements

Optimizing Joins

Optimizing Performance of Distributed Queries

Optimizing Sort Performance with Temporary Tablespaces

Optimizing SQL Statements

Optimizing Star Queries

Optimizing Statements That Access Views

Optimizing Statements that Use Common Subexpressions

Paging and Swapping

Planning File Storage

Preserving Versions of Statistics

Preventing Objects from Aging Out

Pruning Information with Composite Partitioned Objects

Pushing the Join Predicate into a View That Has Multiple Base Tables

Pushing the Predicate into the View

Querying the Output Table

Re-creating Indexes

Reallocating Memory

Recognizing Large Sorts

Reducing Contention for Dispatcher Processes

Reducing Contention for Multi-Threaded Servers

Reducing Contention for Parallel Execution Servers

Reducing Contention for Parallel Execution Servers

Reducing Contention for Redo Copy Latches

Reducing Contention for Redo Log Buffer Latches

Reducing Contention for Rollback Segments

Reducing Contention for Shared Servers

Reducing Contention for the LRU Latch

Reducing Contention for the Redo Allocation Latch

Reducing Data Dictionary Cache Misses

Reducing Disk Contention by Distributing I/O

Reducing Disk I/O Unrelated to Oracle

Reducing Free List Contention

Reducing Latch Contention

Reducing Memory Use With Three-Tier Connections

Reducing Migrated and Chained Rows

Reducing Paging and Swapping

Reducing Parse Calls with Oracle Forms

Reducing Parse Calls with the Oracle Precompilers

Reducing Total Memory Usage

Reducing Unnecessary Parse Calls

Registering Applications

Registering the Dispatchers

Removing Unnecessary Buffers when Cache Hit Ratio Is High

Reparsing SQL Statements

Reserving Space for Large Allocations

Restructuring the Data

Restructuring the Indexes

Restructuring the Statement

Scheduling and Switching

Self-adjusting MTS Architecture Features

Separating Datafiles and Redo Log Files

Separating Tables and Indexes

Setting and Modifying MTS Processes

Setting Initialization Parameters

Setting Performance Targets

Setting the MTS Highwater Mark Equal to MTS_MAX_SERVERS

Setting User Expectations

Sizing Each Buffer Pool

Solving Contention Problems

Solving CPU Problems by Changing System Architectures

Solving I/O Problems

Solving Memory Allocation Problems

Solving Network Problems

Solving Operating System Problems

Sorting to Disk

Sorting to Memory

Specifying a Full Set of Hints

Specifying Hints

Spreading I/O Across Multiple Disks

Storing Outlines

Striping and RAID

Striping Disks

Striping Disks Manually

Striping Disks with Operating System Software

Striping Table Data

Striping Temporary Tablespaces

Testing for Identical SQL Statements

Testing the Performance of Your Disks

Transforming and Optimizing Statements

Transforming Complex Statements into Join Statements

Transforming ORs into Compound Queries

Tuning a Serial SQL Statement

Tuning Backup and Restore Operations

Tuning Checkpoint Activity

Tuning CPU Resources

Tuning DBWR I/O

Tuning Distributed Queries

Tuning Factors for Well Designed Existing Systems

Tuning for the Typical Case

Tuning Goals

Tuning I/O

Tuning I/O: Top Down and Bottom Up

Tuning Instance Recovery Performance

Tuning LGWR and DBWR I/O

Tuning LGWR I/O

Tuning Memory Allocation

Tuning Multiple Buffer Pools

Tuning Networks

Tuning OLTP Applications

Tuning Operating System Memory Requirements

Tuning Parallel Execution

Tuning Private SQL and PL/SQL Areas

Tuning Reserved Space from the Shared Pool

Tuning Resource Contention

Tuning Sort Areas

Tuning Sorts

Tuning the Buffer Cache

Tuning the Buffer Cache Using Multiple Buffer Pools

Tuning the Data Dictionary Cache

Tuning the Duration of Instance and Crash Recovery

Tuning the Large Pool and Shared Pool for the MTS Architecture

Tuning the Library Cache

Tuning the Logical Structure

Tuning the Operating System

Tuning the Phases of Instance Recovery

Tuning the Redo Log Buffer

Tuning the Rolling Back Phase

Tuning the Rolling Forward Phase

Tuning the Shared Pool

Understanding Connection Models

Understanding Contention Issues

Understanding CPU Problems

Understanding EXPLAIN PLAN

Understanding Factors Affecting Data Transfer Rates

Understanding Hints

Understanding I/O Problems

Understanding Instance Recovery

Understanding Latency and Bandwidth

Understanding Memory Allocation Issues

Understanding Operating System Performance Issues

Understanding Oracle Performance Tuning

Understanding SQL Trace and TKPROF

Understanding Statistics

Understanding the SQL Trace Facility

Understanding TKPROF

Upgrading with a Test System

Using Array Interfaces

Using Bitmap Access Plans on Regular B*-tree Indexes

Using Bitmap Indexes

Using Category Names For Stored Outlines

Using Clusters

Using Connection Manager

Using Discrete Transactions

Using Discrete Transactions

Using Domain Indexes

Using Dynamic Performance Views

Using Enabled Novalidated Constraints

Using EXISTS in a SELECT Statement

Using EXISTS in an UPDATE Statement

Using EXISTS versus IN

Using EXPLAIN PLAN

Using EXPLAIN PLAN on All Queries

Using Fast Full Index Scans

Using Fast-Start On-Demand Rollback

Using Fast-Start Parallel Rollback

Using FAST_START_IO_TARGET

Using Fixed Views to Monitor Bottlenecks

Using Function-based Indexes

Using Hash Clusters

Using Hints

Using Hints

Using Hints

Using Hints Against Views

Using Hints with Views

Using Histograms

Using IN in a SELECT Statement with Nested Loop Join

Using Incremental Backups

Using Indexes

Using Initialization Parameters to Control Oracle Trace

Using Initialization Parameters to Influence Recovery Time

Using Locally-Managed Tablespaces

Using LOG_CHECKPOINT_INTERVAL

Using LOG_CHECKPOINT_TIMEOUT

Using Multiple Buffer Pools

Using Nonunique Indexes to Enforce Uniqueness

Using NOSORT to Create Indexes Without Sorting

Using Optimizer Hints

Using Oracle Trace

Using Oracle Trace Data

Using Oracle Trace Data Viewer

Using Oracle Trace Manager

Using Outlines to Move to the Cost-Based Optimizer

Using Plan Stability

Using Plan Stability to Preserve Execution Plans

Using Recovery Manager

Using Redo Log Size to Influence Checkpointing Frequency

Using Serializable Transactions

Using SHARED_POOL_RESERVED_SIZE

Using SORT_MULTIBLOCK_READ_COUNT

Using SQL Statements to Initiate Checkpoints

Using SQL Trace and TKPROF

Using Statistics

Using Stored Outlines

Using Stored Procedures to Control Oracle Trace

Using TCP.NODELAY

Using the ANALYZE Statement

Using the CBO

Using the DBMS_STATS Package

Using the Oracle Trace Command-Line Interface

Using the OUTLN_PKG Package to Manage Stored Outlines

Using the SQL Trace Facility and TKPROF

Using UNION ALL to Skip Partitions

Using Views

Verifying Column Statistics

Verifying Histogram Statistics

Verifying Index Statistics

Verifying Initialization Parameters

Verifying Table Statistics

Viewing Histograms

Viewing Oracle Trace Data

Viewing Outline Data

Viewing Statistics

Writing Similar SQL Statements

Writing Statements that Avoid Using Indexes

Writing Statements that Use Indexes

[Back to top]

Examples of 'design'

This category includes sample procedure and sample code, to illustrate how to perform tasks or use features.

Results in this section come from these books:

[ Next book ]

Designing and Tuning for Performance

Figure 4-1 SQL Processing Architecture

Figure 4-3 Cost-Based Optimizer Architecture

Adjusting Recovery Time: Example Scenario

Calculating Performance Overhead: Example Scenario

Code Examples

Demonstrate Meeting the Objectives

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example

Example 1

Example 1:

Example 1:

Example 1:

Example 1:

Example 1:

Example 1:

Example 1: View with a GROUP BY Clause

Example 1a

Example 1b

Example 1c

Example 2

Example 2

Example 2

Example 2:

Example 2:

Example 2:

Example 2:

Example 2:

Example 2:

Example 2: IN Subquery

Example 2a

Example 2b

Example 2c

Example 3:

Example 3:

Example 3a

Example 3b

Example 4:

Example 4b

Example 5:

Example 6:

Example of Details Property Page

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Example:

Examples

Examples of Common Subexpression Elimination

Figure 1-1 Sequential Processing of Multiple Independent Tasks

Figure 1-2 Wait Time Rising with Increased Contention for a Resource

Figure 1-3 Time to Service Completion vs. Demand Rate

Figure 1-4 Increased Response Time/Reduced Throughput

Figure 1-5 Adjusting Capacity and Functional Demand

Figure 1-6 Who Tunes the System?

Figure 12-1 Foreign Key Constraint

Figure 12-2 Extrapolating Bitmap Index Size: 1 Million Row Table

Figure 12-3 Extrapolating Bitmap Index Size: 5 Million Row Table

Figure 14-1 Integration of Oracle Trace with Other Applications

Figure 14-2 Oracle Trace Data Viewer - Collection Screen

Figure 14-3 Oracle Trace Data Viewer - Data View Screen

Figure 14-4 Oracle Trace Data Viewer - Drill Down Data View Screen

Figure 16-1 Major Performance Factors in Well Designed Systems

Figure 18-1 Average Workload and Peak Workload

Figure 18-2 Single Tier to Two-Tier

Figure 18-3 Multi-Tier Using Smaller Clients

Figure 18-4 Two-Tier to Three-Tier

Figure 18-5 Three-Tier with Multiple Application Servers

Figure 18-6 Oracle Parallel Server

Figure 19-1 Redo Log Buffer

Figure 19-2 Buffer Pool Cache Hit Ratio

Figure 2-1 Cost of Tuning During the Life of an Application

Figure 2-2 Benefit of Tuning During the Life of an Application

Figure 2-3 The Tuning Method

Figure 20-1 Block Size and Application Type

Figure 20-2 Distributing Redo Members Across Disks

Figure 20-3 LRU Latches with Multiple Buffer Pools: Example 1

Figure 20-4 LRU Latches with Multiple Buffer Pools: Example 2

Figure 20-5 Disk Buffer Allocation

Figure 20-6 Tape Buffer Allocation

Figure 20-7 Synchronous I/O

Figure 20-8 Asynchronous I/O

Figure 3-1 Online Transaction Processing Systems

Figure 3-2 Decision Support Systems

Figure 3-3 Parallel Execution Processing

Figure 3-4 A Hybrid OLTP/Data Warehousing System

Figure 3-5 Distributed Database System

Figure 3-6 An Oracle Parallel Server

Figure 4-10 Accessing a View Defined with the UNION Set Operator

Figure 4-11 Accessing a View Defined with a GROUP BY Clause

Figure 4-12 Applying Aggregate Functions to a View Defined with GROUP BY Clause

Figure 4-13 Joining a View Defined with a GROUP BY Clause to a Table

Figure 4-14 Compound Query with UNION ALL Set Operator

Figure 4-15 Compound Query with UNION Set Operator

Figure 4-16 Compound Query with INTERSECT Set Operator

Figure 4-2 An Execution Plan

Figure 4-4 Nested Loops Join

Figure 4-5 Sort-Merge Join

Figure 4-6 Hash Join

Figure 4-7 Cluster Join

Figure 4-8 Execution Plan for a Transformed Query Containing OR

Figure 4-9 Execution Plan for a Nested Loops Join

Figure 7-1 Parallel Hash Anti-join

Figure 9-1 Execution Plan with Two Full Table Scans

Figure 9-2 Execution Plan with a Full Table Scan and an Index Scan

Histogram Example

Partition View Example

Sample Table Scans

Sample TKPROF Output

Table 14-1 Predefined Data Views Provided By Oracle Trace (Page 1 of 5)

Table 14-2 Drill-down Data Views (Page 1 of 2)

Table 14-3 Oracle Trace Initialization Parameters

Table 14-4 Server Event Set File Names  

Table 15-1 Instance Level Views Important for Tuning

Table 15-2 Session Level Views Important for Tuning

Table 16-1 Key to Tuning Areas for Existing Systems

Table 20-1 Relative Disk Speed

Table 20-10 Block Size and Speed of Random Write (Sample Data)

Table 20-11 Block Size Advantages and Disadvantages

Table 20-12 Where to Find Statistics about Oracle Files

Table 20-13 File Throughput Statistics for Oracle Processes

Table 20-14 Minimum Stripe Size

Table 20-15 Typical Stripe Size

Table 20-16 Block Size and Maximum Number of Extents (Typical Values)

Table 20-17 Common Columns of V$BACKUP_SYNC_IO and V$BACKUP_ASYNC_IO

Table 20-18 Columns Specific to V$BACKUP_SYNC_IO

Table 20-19 Columns Specific to V$BACKUP_ASYNC_IO

Table 20-2 Disk I/O Analysis Worksheet

Table 20-20 V$BACKUP_SYNC_IO View

Table 20-21 Throughput Performance Improvement Methods

Table 20-3 Sample Disk I/O Analysis

Table 20-4 Disk I/O Requirements Worksheet

Table 20-5 Sample Disk I/O Requirements

Table 20-6 Read/Write Operations Performed by Oracle Processes

Table 20-7 Block Size and Speed of Sequential Read (Sample Data)

Table 20-8 Block Size and Speed of Sequential Write (Sample Data)

Table 20-9 Block Size and Speed of Random Read (Sample Data)

Table 22-1 Database Configurations

Table 22-2 Bandwidth Ratings

Table 24-1 Initialization Parameters Influencing Checkpoints

Table 24-2 V$INSTANCE_RECOVERY View

Table 5-1 PLAN_TABLE Columns (Page 1 of 3)

Table 5-2 Values of OTHER_TAG Column of the PLAN_TABLE

Table 5-3 Values of DISTRIBUTION Column of the PLAN_TABLE

Table 5-4 OPERATION and OPTION Values Produced by EXPLAIN PLAN (Page 1 of 4)

Table 6-1 SQL Trace Facility Dynamic Initialization Parameters

Table 6-2 TKPROF Arguments

Table 7-1 Distribution Hint Combinations

Table 8-1 Statistics Gathering Procedures in the DBMS_STATS Package

Table 8-2 Default Table and Index Values When Statistics are Missing

Table 9-1 Contrasting Goals for Tuning

Table 9-2 SQL Tuning Tips

TKPROF Output Example

TKPROF Statement Examples

[ Previous book | Next book ]

Application Developer's Guide - Fundamentals

Figure 5-2 WEATHERDATA_TAB Schema Design

[ Previous book | Next book ]

Application Developer's Guide - Large Objects (LOBs)

Figure 8-4 Schema Design for Inclusion of VOICED_REF Reference

Figure 8-5 Schema Design for Inclusion of Nested Table INSEG_NTAB

Figure 8-6 Schema Design for Inclusion of Column Object MAP_OBJ

[ Previous book | Next book ]

Application Developer's Guide - XML

Figure 2-4 Scenario 4. Online Multivendor Shopping Cart Design Using XML

Scenario 4. B2B Messaging: Online Multivendor Shopping Cart Design Using XML

[ Previous book | Next book ]

Applications InterConnect User's Guide

Figure 2-2 A graphical overview of design time and runtime phases in integration

[ Previous book | Next book ]

Data Warehousing Guide

Figure 3-1 Logical Design Compared with Physical Design

[ Previous book | Next book ]

Parallel Server Administration, Deployment, and Performance

Figure A-3 Case Study: Partitioning Users and Data: Design Option 1

Figure A-4 Case Study: Partitioning Users and Data: Design Option 2

[Back to top]

Detailed Reference Information on 'design'

This category includes syntax for associated statements, APIs, or commands.

Results in this section come from these books:

[ Next book ]

Designing and Tuning for Performance

EXPLAIN PLAN

EXPLAIN PLAN

[ Previous book | Next book ]

PL/SQL User's Guide and Reference

Easier Application Design

[Back to top]

Troubleshooting Information About 'design'

This category includes information about debugging, preventing errors or handling them when they occur, frequently asked questions, and relevant error messages.

Results in this section come from these books:

[ Next book ]

Designing and Tuning for Performance

11 Overview of Diagnostic Tools

16 Diagnosing System Performance Problems

Adjustments to Relieve Problems

Avoid Common Errors

Avoiding Balloon Tactic for Coding SQL

Avoiding Complex Expressions

Avoiding Dynamic Space Management

Avoiding Dynamic Space Management in Rollback Segments

Avoiding Pitfalls in TKPROF Interpretation

Avoiding Rule-Based Optimizer Techniques

Bitmap Index Restrictions

Detecting and Solving CPU Problems

Detecting Contention Problems

Detecting I/O Problems

Detecting Memory Allocation Problems

Detecting Network Problems

Detecting Operating System Problems

Determine if the Problem is with Net8 or the Network

Determining the Problem

Diagnosing System Performance Problems

Distributed Query Restrictions

Errors During Discrete Transactions

Errors in All: Client, Server, and Listener Trace

Errors Only in the Client Trace

Errors Only in the Server Trace or Listener Trace

Evaluating Unlimited Extents

EXPLAIN PLAN Restrictions

Limiting Memory Use Per User Session by Setting PRIVATE_SGA

On Net8, Determine if the Problem is on the Client or the Server

Oracle Diagnostics Pack

Overview of Diagnostic Tools

Restrictions

Scalability Limitations Within the Application

Solving Contention Problems

Solving CPU Problems by Changing System Architectures

Solving I/O Problems

Solving Memory Allocation Problems

Solving Network Problems

Solving Operating System Problems

Trouble Shooting

Understanding CPU Problems

Understanding I/O Problems

[ Previous book | Next book ]

Data Cartridge Developer's Guide

Text Indextype Designer

[ Previous book | Next book ]

Enterprise Manager Messages Manual

VTM-0098: The selected data item cannot be modified because it is the currently designated data source for the chart. Designate another data item as the data source and retry the operation.

[ Previous book | Next book ]

Error Messages

ORA-06401 NETCMN: invalid driver designator

[ Previous book | Next book ]

SQLJ Developer's Guide and Reference

Size designation size hint for parameter param ignored.

[Back to top]

Index Entries about 'design'

The index entries show related terms, and identify the most important places where your subject is mentioned.
IM RE MO DE TO OB AP

Index Entries

application design (Designing and Tuning for Performance)
application designer (Designing and Tuning for Performance)
Design and Modeling (Application Developer's Guide - Advanced Queuing (AQ))
     [entry #2] (Application Developer's Guide - Advanced Queuing (AQ))
design dictionary (Designing and Tuning for Performance)
design issues (Application Developer's Guide - XML)
design time (Applications InterConnect User's Guide)
designing management applications (Enterprise Manager SNMP Support Reference Guide)
implementing database design (Administrator's Guide)
Modeling and Design (Application Developer's Guide - Advanced Queuing (AQ))
     [entry #2] (Application Developer's Guide - Advanced Queuing (AQ))
Object Database Designer (Getting to Know Oracle8i)
object-relational design (Application Developer's Guide - Large Objects (LOBs))
top-down design (PL/SQL User's Guide and Reference)
[Back to top]

Bibliography

The links on this page lead to many different books. This section lists PDF files that you can download and print, if you want to do further reading. This section also identifies the relevant chapters that you can print out, rather than printing the entire book.

PDF FileMajor Topics to Print
Application Developer's Guide - Advanced Queuing (AQ)
  • Modeling and Design
Application Developer's Guide - Fundamentals
  • Managing Tables
  • Using CHECK Integrity Constraints
  • Using Function-Based Indexes
  • Using Triggers
  • Designing the Database
Application Developer's Guide - Large Objects (LOBs)
  • Modeling and Design
  • A Sample Application
  • Structure of Multimedia_tab Table
Application Developer's Guide - Object-Relational Features
  • General Questions about Oracle Objects
Application Developer's Guide - XML
  • Introduction to Oracle XML
  • Scenario 4. B2B Messaging: Online Multivendor Shopping Cart Design Using XML
Applications InterConnect User's Guide
  • Design Time Concepts and iStudio
  • Integration Process Overview
Data Cartridge Developer's Guide
  • Using Cartridge Services
Data Warehousing Guide
  • Overview of Logical Design
  • The Need for Materialized Views
  • Overview of Physical Design
  • Moving from Logical to Physical Design
Designing and Tuning for Performance
  • Managing Shared SQL and PL/SQL Areas
  • Comparing SQL Statements and PL/SQL Blocks
  • Keeping Shared SQL and PL/SQL in the Shared Pool
  • Preventing Objects from Aging Out
  • Overview of Diagnostic Tools
  • Sources of Data for Tuning
  • Oracle Enterprise Manager, Packs, and Applications
  • Using EXPLAIN PLAN
  • Output Table Columns
  • EXPLAIN PLAN and Partitioned Objects
  • Displaying Range and Hash Partitioning with EXPLAIN PLAN
  • Pruning Information with Composite Partitioned Objects
  • Partial Partition-wise Joins
  • Using SQL Trace and TKPROF
  • Understanding SQL Trace and TKPROF
  • Step 1: Setting Initialization Parameters for Trace File Management
  • Step 3: Formatting Trace Files with TKPROF
  • Step 4: Interpreting TKPROF Output
  • Step 5: Storing SQL Trace Facility Statistics
  • Using Oracle Trace
  • Introduction to Oracle Trace
  • Using Oracle Trace Data
  • Using Oracle Trace Manager
  • Using Oracle Trace Data Viewer
  • Oracle Trace Predefined Data Views
  • Viewing Oracle Trace Data
  • Getting More Information on a Selected Query
  • Manually Collecting Oracle Trace Data
  • Using Initialization Parameters to Control Oracle Trace
  • Using Stored Procedures to Control Oracle Trace
  • Instance-Level Views for Tuning
  • Session-Level or Transient Views for Tuning
  • Current Statistic Values and Rates of Change
  • Diagnosing System Performance Problems
  • Tuning Factors for Well Designed Existing Systems
  • Tuning CPU Resources
  • Understanding CPU Problems
  • System CPU Utilization
  • Oracle CPU Utilization
  • Single Tier to Two-Tier
  • Multi-Tier: Using Smaller Client Machines
  • Two-Tier to Three-Tier
  • Three-Tier
  • Oracle Parallel Server
  • Tuning Memory Allocation
  • Solving Memory Allocation Problems
  • Tuning Operating System Memory Requirements
  • Tuning the Redo Log Buffer
  • Tuning Private SQL and PL/SQL Areas
  • Tuning the Shared Pool
  • Tuning the Buffer Cache
  • Tuning Multiple Buffer Pools
  • Understanding Oracle Performance Tuning
  • What Is Performance Tuning?
  • Trade-offs Between Response Time and Throughput
  • Critical Resources
  • Effects of Excessive Demand
  • Adjustments to Relieve Problems
  • Who Tunes?
  • Tuning I/O
  • Understanding I/O Problems
  • Analyzing I/O Requirements
  • Planning File Storage
  • Choosing Data Block Size
  • Evaluating Device Bandwidth
  • Detecting I/O Problems
  • Checking Oracle I/O Utilization
  • Solving I/O Problems
  • Reducing Disk Contention by Distributing I/O
  • Striping Disks
  • Avoiding Dynamic Space Management
  • Tuning Sorts
  • Tuning Checkpoint Activity
  • Tuning LGWR and DBWR I/O
  • Tuning Backup and Restore Operations
  • Tuning Resource Contention
  • Solving Contention Problems
  • Reducing Contention for Rollback Segments
  • Reducing Contention for Multi-Threaded Servers
  • Reducing Contention for Parallel Execution Servers
  • Reducing Contention for Redo Log Buffer Latches
  • Reducing Free List Contention
  • Tuning Networks
  • Understanding Connection Models
  • Detecting Network Problems
  • Understanding Latency and Bandwidth
  • Solving Network Problems
  • Dissecting Bottlenecks
  • Tuning the Operating System
  • Understanding Operating System Performance Issues
  • Performance Tuning Methods
  • Proactive Tuning While Designing and Developing Systems
  • Prioritized Tuning Steps
  • Applying the Tuning Method
  • Application and System Performance Characteristics
  • Online Transaction Processing (OLTP)
  • Decision Support Systems
  • Multipurpose Applications
  • Distributed Systems
  • Oracle Parallel Server
  • Data Access Methods
  • Using Indexes
  • Tuning the Logical Structure
  • Using Fast Full Index Scans
  • Using Bitmap Indexes
  • Creating Bitmap Indexes
  • Estimating Bitmap Index Size
  • Using Hash Clusters
  • Transaction Modes
  • Using Discrete Transactions
  • Tuning Instance Recovery Performance
  • Tuning the Duration of Instance and Crash Recovery
  • Using Initialization Parameters to Influence Recovery Time
  • Monitoring Instance Recovery
  • Tuning the Phases of Instance Recovery
  • Tuning the Rolling Back Phase
  • Using Optimizer Hints
  • Understanding Hints
  • Specifying Hints
  • Using Hints
  • Hints for Optimization Approaches and Goals
  • Hints for Access Methods
  • Hints for Join Operations
  • Hints for Parallel Execution
  • Additional Hints
  • The Optimizer
  • SQL Processing Architecture
  • Execution Plan
  • Choosing an Optimizer Approach and Goal
  • Changing the Goal with Hints
  • Cost-Based Optimizer (CBO)
  • Architecture of the CBO
  • Access Paths for the CBO
  • How the CBO Chooses an Access Path
  • CBO Parameters
  • Setting Initialization Parameters
  • Access Paths for the RBO
  • Optimizing Joins
  • Join Operations
  • Choosing Execution Plans for Join Statements
  • Optimizing Statements that Use Common Subexpressions
  • Transitivity
  • Transforming and Optimizing Statements
  • Transforming ORs into Compound Queries
  • Transforming Complex Statements into Join Statements
  • Optimizing Statements That Access Views
  • Optimizing Compound Queries
  • Using Plan Stability
  • Using Plan Stability to Preserve Execution Plans
  • Hints and Exact Text Matching
  • Creating Outlines
  • Plan Stability Procedures for the Cost-Based Optimizer
  • RDBMS Upgrades and the Cost-Based Optimizer
  • Introduction to Tuning
  • Optimizing Instance Performance
  • Conventions
  • Optimizing SQL Statements
  • Approaches to SQL Statement Tuning
  • Restructuring the Statement
  • Tuning Goals
  • Best Practices
  • SQL Tuning Tips
  • Using EXISTS versus IN
  • Tuning Distributed Queries
  • Remote and Distributed Queries
  • Transparent Gateways
  • Gathering Statistics
  • Generating Statistics
  • Using the DBMS_STATS Package
  • Missing Statistics
  • Using Statistics
  • Managing Statistics
  • Using Histograms
  • Creating Histograms
  • Types of Histograms
  • Contents
Enterprise Manager Messages Manual
Enterprise Manager SNMP Support Reference Guide
  • Designing Management Applications Based on Oracle MIBs
Error Messages
Integration Server Overview
  • Overview of Oracle Integration Server
Parallel Server Administration, Deployment, and Performance
  • A Case Study in Parallel Server Database Design
  • Case Study: Further Partitioning Plans
PL/SQL User's Guide and Reference
  • Advantages of Packages
Pro*C/C++ Precompiler Programmer's Guide
  • Guidelines
Pro*COBOL Precompiler Programmer's Guide
  • Guidelines for Transaction Processing
Replication
  • Advanced Concepts & Architecture
  • Designing for Survivability
SQLJ Developer's Guide and Reference
WebDB Tutorial Guide
  • Designing WebDB Sites

Oracle
Copyright © 2024, Oracle and/or its affiliates. All rights reserved.