Muutke küpsiste eelistusi

Beginning Oracle PL/SQL 2nd ed. [Pehme köide]

4.00/5 (2 hinnangut Goodreads-ist)
  • Formaat: Paperback / softback, 492 pages, kõrgus x laius: 254x178 mm, kaal: 9149 g, 80 Illustrations, black and white; XXXIV, 492 p. 80 illus., 1 Paperback / softback
  • Ilmumisaeg: 30-Apr-2015
  • Kirjastus: APress
  • ISBN-10: 1484207386
  • ISBN-13: 9781484207383
Teised raamatud teemal:
  • Pehme köide
  • Hind: 71,86 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Tavahind: 84,54 €
  • Säästad 15%
  • Raamatu kohalejõudmiseks kirjastusest kulub orienteeruvalt 2-4 nädalat
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Tellimisaeg 2-4 nädalat
  • Lisa soovinimekirja
Beginning Oracle PL/SQL 2nd ed.Suurem pilt
  • Formaat: Paperback / softback, 492 pages, kõrgus x laius: 254x178 mm, kaal: 9149 g, 80 Illustrations, black and white; XXXIV, 492 p. 80 illus., 1 Paperback / softback
  • Ilmumisaeg: 30-Apr-2015
  • Kirjastus: APress
  • ISBN-10: 1484207386
  • ISBN-13: 9781484207383
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9781484207383.html
Märksõnad:
Beginning Oracle PL/SQL gets you started in using the built-in language that every Oracle developer and database administrator must know. Oracle Database is chock-full of built-in application features that are free for the using, and PL/SQL is your ticket to learning about and using those features from your own code. With it, you can centralize business logic in the database, you can offload application logic, and you can automate database- and application-administration tasks.

Author Don Bales provides in Beginning Oracle PL/SQL a fast-paced and example-filled tutorial. Learn from Dons extensive experience to discover the most commonly used aspects of PL/SQL, without wasting time on obscure and obsolete features.

The author takes his 20+ years of experience and a wealth of statistics he's gathered on PL/SQL usage over those years and applies the 80/20 rule: cover what's most needed and used by PL/SQL professionals and avoid what's not necessary! The result is a book that covers all the key features of PL/SQL without wasting your time discussing esoteric and obsolete parts of the language. Learn what really matters, so that you can get to work feeling confident with what you know about PL/SQL.





Covers the key topics that matter, including variables and datatypes, executing statements, working with cursors, bulk operations, real-world objects, debugging, testing, and more.



Teaches you to write production-level, object-oriented PL/SQL. You'll explore relational PL/SQL, but unlike most other books on the subject, this one emphasizes the use of PL/SQLs object-oriented features as well.



Guides you in working through real examples of using of PL/SQL. You'll learn PL/SQL by applying it to real-world business problems, not by heavy theory.
About the Author xvii
About the Technical Reviewer xix
Acknowledgments xxi
Foreword xxiii
Introduction (The Big Picture) xxv
Chapter 1 Relational SQL 1(36)
Tables
1(4)
An Entity-Relationship Diagram
3(1)
Data Definition Language (DDL)
3(1)
It's Your Turn to Create a Table
4(1)
Indexes
5(1)
DDL Again
5(1)
It's Your Turn to Create an Index
6(1)
Constraints
6(3)
Column Constraints
6(1)
Table Constraints
7(2)
It's Your Turn to Create a Constraint
9(1)
Triggers
9(2)
Views
11(1)
Insert
12(6)
Insert...Values
12(1)
It's Your Turn to Insert with Values
13(1)
Insert...Select
14(2)
It's Your Turn to Insert with Select
16(2)
Update
18(2)
Fix a Mistake with Update
18(1)
It's Your Turn to Update
19(1)
Update and Subqueries
19(1)
Delete
20(1)
A Change in Order
20(1)
It's Your Turn to Delete
21(1)
Select
21(4)
Joins
22(2)
It's Your Turn to Select
24(1)
Your Working Example
25(11)
Your Example Narrative
25(1)
Your Example ERD
25(3)
Create a Code Table
28(4)
It's Your Turn to Create Code Tables
32(1)
Create a Content Table
32(2)
It's Your Turn to Create Content Tables
34(1)
Create an Intersection Table
35(1)
It's Your Turn to Create Intersection Tables
36(1)
Summary
36(1)
Chapter 2 Blocks, Functions, and Procedures 37(24)
Blocks
37(2)
Anonymous Blocks
37(2)
Exceptions
39(1)
Common Exceptions
40(1)
Catching an Exception
40(1)
Functions
40(4)
Create a Function
40(3)
It's Your Turn to Create a Function
43(1)
Procedures
44(4)
Create a Procedure
45(1)
It's Your Turn to Create a Procedure
46(2)
Nested Blocks
48(3)
An Example of Nesting Blocks
48(2)
Rules for Nesting
50(1)
Packages
51(9)
Create a Package Specification
51(2)
It's Your Turn to Create a Package Specification
53(1)
Create a Package Body
54(5)
It's Your Turn to Create a Package Body
59(1)
Benefits of Using Packages
60(1)
Summary
60(1)
Chapter 3 Types, Variables, and Scope 61(26)
PL/SQL Data Types
61(1)
Variables
62(5)
Variable Naming
62(1)
Variable Declarations
63(1)
Variable Anchors
63(1)
Variable Assignments
64(2)
NULL Value
66(1)
It's Your Turn to Declare Variables
66(1)
Scope
67(6)
Scope Rules
67(5)
It's Your Turn to Scope Things Out
72(1)
Types
73(6)
Table Types
73(4)
Record Types
77(1)
Multidimensional Arrays
78(1)
Parameters
79(6)
Parameter Naming
79(1)
Parameter Declarations
80(1)
Parameter Scope
81(4)
It's Your Turn to Declare Parameters
85(1)
Summary
85(2)
Chapter 4 Single Row Processing 87(32)
Inserts
87(19)
Catching a DUP_VAL_ON_INDEX Exception
91(3)
Using PUSQL to Predetect a Duplicate
94(6)
IF I Don't Tell You Now, When ELSE Can I?
100(1)
Using SQL to Predetect a Duplicate
100(4)
It's Your Turn to Insert
104(2)
Updates
106(3)
Updating a Row
107(1)
Using SQL to Perform Complex Updates
107(2)
Deletes
109(1)
Selects
110(6)
No Data Found
112(2)
Too Many Rows
114(1)
It's Your Turn to Select
115(1)
Summary
116(3)
Chapter 5 Multirow Processing 119(32)
Cursors
119(19)
Cursor Declarations
119(1)
Fetching Rows from a Cursor Manually
120(2)
Cursor Records
122(1)
A Singleton Cursor
122(5)
It's Your Turn to Fetch Manually
127(7)
Fetching Rows from a Cursor Automatically
134(1)
It's Your Turn to Fetch Automatically
135(3)
Bulk Collect
138(7)
Bulk Collect with a Cursor
139(2)
Bulk Collect with a Select Statement
141(1)
It's Your Turn to Bulk Collect
142(3)
FORALL
145(5)
Summary
150(1)
Chapter 6 Object-Relational SQL 151(46)
Information Modeling
151(2)
Object Orientation
153(1)
Key Tenets
153(1)
Reuse
154(1)
Service Orientation
154(1)
A Roadmap to Reality
155(2)
Step 1 Table Packages
155(1)
Step 2 User-Defined Types
156(1)
Step 3 Object Views
156(1)
Step 4 Object Tables
156(1)
A Change in Order
157(1)
Object Types
157(14)
Create a User-Defined Type Specification
158(3)
Create a User-Defined Type Implementation
161(5)
It's Your Turn to Create a User-Defined Type
166(5)
Object Views
171(3)
Create an Object View
171(3)
It's Your Turn to Create an Object View
174(1)
Object Tables
174(4)
Create an Object Table
174(2)
It's Your Turn to Create an Object Table
176(2)
Impedance Mismatch?
178(18)
Nested Types and Collections
179(2)
It's Your Turn to Prove There's No Impedance Mismatch
181(15)
Summary
196(1)
Chapter 7 Troubleshooting 197(60)
Prevention
198(2)
Anchors
198(1)
Data Type Prefixes
199(1)
Explicit Conversions
199(1)
Preparation
200(3)
Blocking
200(2)
Bread Crumbs
202(1)
After the Fact
203(4)
Success Messages
203(2)
Failure Messages
205(1)
It's Your Turn to Use put_line()
205(2)
As It Happens
207(20)
A DEBUG Table
207(9)
A DEBUGGER Package
216(4)
It's Your Turn to Use Debug Logging
220(7)
One Step at a Time
227(7)
Debugging with Oracle SQL Developer
227(6)
Debugging Anonymous PUSQL
233(1)
Debugging with TOAD for Oracle
233(1)
Debugging with Visual Studio
233(1)
It's Your Turn to Use a Debugger
233(1)
Profiling PL/SQL
234(10)
Profiler's Tables
234(1)
Profiler's Methods
235(1)
Profiling Reports
236(5)
It's Your Turn to Profile
241(3)
Profiling SQL
244(11)
Explain Plan
244(4)
Physics vs. Explain Plan
248(2)
It's Your Turn to Use Explain Plan
250(5)
TKPROF
255(1)
Summary
255(2)
Chapter 8 Testing 257(70)
SQL Test Patterns
259(1)
PL/SQL Test Patterns
260(1)
A Testing Tool
261(27)
A TEST Table
264(1)
A TEST Package Specification
265(4)
A TEST Package Body
269(6)
It's Your Turn to Create a Testing Tool
275(13)
Testing
288(32)
Testing a Code Table Package
288(11)
It's Your Turn to Test a Code Table Package
299(1)
Testing a Content Table Package
299(7)
It's Your Turn to Test a Content Table Package
306(1)
Testing an Intersection Table Package
306(10)
It's Your Turn to Test an Intersection Table Package
316(1)
Testing a Type
317(3)
It's Your Turn to Test a Type
320(1)
Automating Testing
320(6)
Automate Test Processing
321(5)
It's Your Turn to Automate Test Processing
326(1)
Summary
326(1)
Chapter 9 Documenting 327(38)
Indestructible Documentation
328(6)
SQLPlus Documentation Tools
328(2)
GUI Development Environment Tools
330(3)
Rules for Documentation Comments
333(1)
Documentation on Demand
334(6)
A Text-Based Documentation Formatting Tool
334(4)
Accessing Documentation on Demand
338(1)
It's Your Turn to Access Documentation on Demand
339(1)
Distributable Documentation
340(22)
An HTML-Based Documentation Formatting Tool
340(20)
Generating Distributable Documentation
360(2)
It's Your Turn to Generate Distributable Documentation
362(1)
Documentation Distribution
362(1)
Summary
363(2)
Chapter 10 Examples 365(60)
Polymorphic Commands
366(3)
Parametric SQL
369(16)
Code Table Methods
369(3)
Content Table Methods
372(6)
Intersection Table Methods
378(3)
Hierarchical Table Methods
381(4)
The Black Box
385(6)
Table Methods
385(1)
Universal Methods
386(5)
Divide and Conquer
391(31)
Data Migration
392(4)
On-Demand Data Processing
396(3)
Polling Data Processing
399(8)
Interfacing
407(7)
Reporting
414(8)
Summary
422(3)
Appendix A: How to Download, Install, and Use Oracle 425(22)
How to Download Oracle Database Software
425(6)
How to Install Oracle Database Software
431(9)
How to Use SQLPlus
440(7)
How to Download This Book's Source Code
441(3)
How to Create a New Username
444(1)
How to Write a SQLPlus Script
444(1)
How to Execute a SQLPlus Script
444(1)
How to Describe Your Tables and Stored Procedures
445(2)
Index 447
Donald Bales is a computer applications consultant specializing in the analysis, design, and programming of client-server and web-based distributed systems, systems integration, and data warehousing. Don has over 20 years of experience with Oracle as both a developer and a database administrator, and 10 years of experience with Java. He is currently working on the migration of medical and industrial hygiene systems to a web environment for a major oil company. When he is not developing applications, Donald can often be found working with horses, playing the piano, or playing the bagpipes. Donald has had several careers, and has at various times been a mechanic, a general contractor, Mr. Mom, a developer, and currently a consultant. He has a bachelor of science degree in business from Elmhurst College in Illinois. Don resides in Downers Grove, Illinois, with his wife, Diane, and his daughter, Kristyn. He can be contacted by e-mail at don@donaldbales.com.