Muutke küpsiste eelistusi

Oracle Design: Database & Code Design [Raamat]

  • Formaat: Book, 526 pages
  • Ilmumisaeg: 08-Apr-1997
  • Kirjastus: O'Reilly Media
  • ISBN-10: 1565922689
  • ISBN-13: 9781565922686
Teised raamatud teemal:
  • Raamat
  • Hind: 63,99 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
Oracle Design: Database & Code DesignSuurem pilt
  • Formaat: Book, 526 pages
  • Ilmumisaeg: 08-Apr-1997
  • Kirjastus: O'Reilly Media
  • ISBN-10: 1565922689
  • ISBN-13: 9781565922686
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9781565922686.html
Märksõnad:
Covers database, code, and architecture design for the Oracle operating system. The text is arranged in four sections including an overview of Oracle and data modeling; aspects of database design including denormalization, data types, nulls, keys, indexes, temporal data, import/export, backup, recovery, security, archiving, and audit; examples of architecture design issues for client/server, distributed databases, data warehouses, and parallel processing; and aspects of code design including metrics and prototypes, locking, and the design of screens, reports, batch programs, online help text, and navigation. Annotation c. by Book News, Inc., Portland, Or.

This book focuses exclusively on Oracle database design. It covers the most up-to-date Oracle issues and technologies, including massively parallel processors, very large databases, data warehouses, client-server, and distributed database. The design advice is detailed and thorough. The book delves deeply into design issues and gives advice that will have a major impact on your database and system performance.

Oracle Design looks thoroughly at the field of Oracle relational database design. The design of both databases and applications is an often neglected area of Oracle, but one that has an enormous impact on the ultimate power and performance of a system. If the initial design is poor, then the most powerful hardware, the most sophisticated software tools, and the most highly tuned data and programs won't make your system run smoothly and efficiently. Indeed, applications that have been designed poorly will never be able to perform well, regardless of the tuning and retrofitting performed later on.

There are three main areas of Oracle design:

  • The design of the specific database objects (e.g., tables, views, indexes, stored functions) that will be implemented in a database.
  • The design of the screens, reports, and programs that will maintain the data and allow inquiries against it.
  • Under certain circumstances, the design must also be concerned with the specific environment or technology (e.g., the network topology, the hardware configuration, and the use of a client/server, parallel processing, or distributed database architecture).

This book examines all aspects of database and code design. Part I examines the project life cycle and where design fits in that cycle; it shows a sample case study, identifies the areas of Oracle7 that are of particular interest to designers, takes a look ahead at Oracle8, and provides an in-depth discussion of data modeling (e.g., entities, relationships, attributes, entity models, function hierarchies). Part II describes design issues for the database itself -- denormalization, data types, keys, indexes, temporal data, import/export, backup, recovery, security, and more. Part III explores design issues for specific architectures and environments -- client/server, distributed database, data warehouses, and parallel processing. Part IV describes design issues for the code that accesses the database -- metrics and prototypes, locking, the toolset, design of screens, reports, batch programs, etc. Part V contains summary appendixes.

The table of contents follows:

Part I: Getting Started with Design

  • 1. Introduction
  • 2. Why is Design so Important for Oracle?
  • 3. Data Modeling
Part II: Designing the Database
  • 4. Deciding When to Denormalize
  • 5. Choosing Data Types and NULLs
  • 6. Choosing Keys and Indexes
  • 7. Dealing with Temporal Data
  • 8. Loading and Unloading Data
  • 9. Deciding on Object Placement and Storage
  • 10. Safeguarding Your Data
Part III: Designing for Specific Architectures
  • 11. Designing for Client/Server
  • 12. Designing Distributed Databases
  • 13. Designing for Data Warehouse
  • 14. Designing for Parallel Processing

Part IV: Designing the Code Modules

  • 15. Introduction to Code Design
  • 16. Determining Where to Locate the Processing
  • 17. Metrics, Prototypes, and Specifications
  • 18. Locking
  • 19. Selecting the Toolset
  • 20. Designing Screens, Reports, Batch Programs, Error Handling, and Help
Part V: Appendixes
  • A. Off-the-Shelf Packages
  • B. Tricks of the Trade


This book focuses exclusively on Oracle database design. It covers the most up-to-date Oracle issues and technologies, including massively parallel processors, very large databases, data warehouses, client-server, and distributed database. The design advice is detailed and thorough. The book delves deeply into design issues and gives advice that will have a major impact on your database and system performance.
Preface xi
I. Getting Started With Design 1(98)
1. Introduction
3(32)
What Is Design?
3(1)
A Case Study
4(11)
Looking at Alternative Methods and Approaches
15(3)
Planning the Design Phase
18(2)
Design Tasks
20(15)
2. Why Is Design So Important for Oracle?
35(25)
Designing for Specific Architectures
35(4)
Designing for Performance
39(3)
Other Design Considerations
42(2)
Designing for Oracle7
44(14)
Introducing Oracle8
58(2)
3. Data Modeling
60(39)
Types of Models
61(1)
What Is Data Modeling?
62(3)
Entity Relationship Diagrams
65(4)
Quality-Assuring the Conceptual Information Model
69(23)
Entity Life Histories and Data Flow Diagrams
92(4)
Data-Driven Design and Meta Models
96(3)
II. Designing the Database 99(166)
4. Deciding When to Denormalize
101(12)
Denormalization: What, Why, and When?
101(4)
Methods of Implementing Denormalization
105(2)
Other Types of Denormalization
107(6)
5. Choosing Datatypes and Nulls
113(18)
Available Datatypes
114(1)
Numeric Data
115(2)
Date and Time (Temporal) Data
117(2)
String Data
119(3)
Unstructured Data and BLOBs
122(1)
Other Datatypes
123(2)
Null Values
125(6)
6. Choosing Keys and Indexes
131(33)
Primary Keys
132(9)
Other Keys
141(2)
Indexes: An Overview
143(4)
Index Types and Indexing Techniques
147(17)
7. Dealing with Temporal Data
164(27)
The Problem with Temporal Data
164(4)
Design Issues for Temporal Databases
168(21)
Temporal Data: A Summary
189(2)
8. Loading and Unloading Data
191(24)
Dealing with External Systems
191(3)
Data Compatibility Issues
194(7)
Data Migration Steps
201(2)
Data Transformation
203(4)
File Formats
207(1)
Ordering, Recovery, and Commit Frequency
208(1)
Using SQL*Loader
209(2)
Oracle7 to Oracle7: a Special Case
211(2)
Outbound Data
213(2)
9. Deciding on Object Placement and Storage
215(10)
Specifying Object Placement
215(3)
Sizing
218(2)
Specifying Storage Parameters
220(3)
Creating Scripts
223(1)
Implementation Planning
223(2)
10. Safeguarding Your Data
225(40)
Archiving
226(7)
Auditing
233(10)
Security
243(12)
Backup
255(10)
III. Designing for Specific Architectures 265(126)
11. Designing for Client/Server
267(32)
Why Client/Server?
268(1)
What Is Client/Server?
269(1)
What Kind of Hardware?
270(2)
Basic Design Issues for Client/Server
272(1)
Designing for Client/Server
273(3)
SQL*Net Basics
276(1)
Anatomy of a SQL Statement
277(3)
Cutting in the Middle Man
280(2)
Special Design Considerations
282(17)
12. Designing for Distributed Databases
299(36)
When Should You Use Distributed Databases?
299(1)
Evolution of Oracle Support for Data Distribution
300(12)
Selecting a Data Distribution Strategy
312(16)
Example Scenarios
328(4)
Using Distributed Database for Fallback
332(1)
Other Design Considerations
332(1)
Data Distribution Summary
333(2)
13. Designing for Data Warehouses
335(34)
Why Data Warehouses?
335(2)
What Is a Data Warehouse?
337(10)
Design Issues for Data Warehouses
347(11)
Extracting and Loading the Data
358(6)
Meta Data
364(1)
Transformation Types and Methods
364(3)
Retrieving the Data via Data Mining and OLAP Tools
367(2)
14. Designing for Parallel Processing
369(22)
Why Do We Need Parallelism?
370(5)
Designing to Achieve Parallelism
375(5)
Parallel Query Option (PQO)
380(4)
Oracle Parallel Server (OPS)
384(7)
IV. Designing the Code Modules 391(84)
15. Introduction to Code Design
393(17)
Analysis Deliverables
394(3)
Mapping Functions to Modules
397(2)
Don't Forget the System Modules
399(3)
Source and Version Control
402(3)
Template Code
405(1)
Designing for Testing
406(1)
CASE Products in Run Unit Design
407(3)
16. Determining Where to Locate the Processing
410(13)
Data Rules vs. Process Rules vs. Interface Rules
410(6)
Logic Placement
416(2)
Locking Issues
418(2)
How Does This Relate to Three-Tier Architectures?
420(3)
17. Metrics, Prototypes, and Specifications
423(14)
Developing Design and Build Metrics for Modules
423(2)
Banishing Megamodules
425(3)
Shall We Prototype?
428(5)
Where are my Specs? Guidelines for Module Specifications
433(2)
Specifying Screens and Reports
435(1)
Specifying Batch Processes
436(1)
18. Locking
437(9)
Locking Strategies
437(3)
Deadlocks
440(1)
Serializability
441(1)
Other Design Issues
442(4)
19. Selecting the Toolset
446(7)
Types of Tools
446(1)
Which Selection Criteria Are Important?
447(1)
Client/Server Tools
448(3)
Designing for the World Wide Web
451(2)
20. Designing Screens, Reports, Batch Programs, and More
453(22)
Designing Screens
453(3)
Designing Reports
456(2)
Designing Batch Programs
458(10)
Error Handling
468(1)
Navigation
469(2)
Online Help
471(4)
V. Appendixes 475(38)
A. Off-the-Shelf Packages
477(10)
Evaluating a Package
478(1)
Does It Fit?
479(4)
Can It Be Tailored?
483(2)
The Big Data Model Issue
485(2)
B. Tricks of the Trade
487(26)
Fixing Those Mutating Tables
487(8)
Dealing with the Millennium Date Problem: An Oracle Perspective
495(8)
Providing User Extensibility
503(10)
Index 513
Dave Ensor is manager of Worldwide Solutions, PATROL R&D, with BMC Software where his roles are to assist customers in their use of both BMC's PATROL product and the Oracle Server, and to feed the results of his field work back into product planning. He has more than 30 years of IT experience and has been involved with the design and performance issues surrounding Oracle since 1987. For many years he led Oracle Worldwide's Performance Studies Group based in the UK, which provided consultancy support to both customer and internal projects with critical performance requirements. Dave is well known as a speaker on performance management and design; he presents his papers at user conferences and writes and delivers one-day seminars. He lives in the UK just outside London, but spends much of the year traveling to user sites and meetings. In his spare time he also travels, but in this case without his laptop and with his wife. He can be reached at dave_ensor@compuserve.com. Ian Stevenson is a freelance consultant specializing in database design and development. He has worked with database technology for 19 years, starting with early hierarchical models. He worked for Oracle (UK) for two years in post-sales support and Human Resources Development. This is where he formed his friendship with Dave Ensor. Ian has a first class honours degree in mathematics from the University of Southampton and is a member of the British Computer Society. He is married to Brenda and has two children, Todd and Tara. He is a fanatic supporter of the Southampton football club. He can be contacted via ian@westmail.demon.co.uk.