Symbols | A | B | C | D | E | F | G | H | I | K | L | M | N | O | P | Q | R | S | T | U | V | W | Y | Z

Index: P

• package
• • Supporting many data combinations
  • Building Blocks
  • a DBMS_OUTPUT Substitute
  • A Powerful Substitute for DBMS_OUTPUT
  • l : (see procedure)
  • output from : Controlling Output from p
• package libraries : Prebuilt Packages
• packages
• • (see also modularizing)
  • Builtin Packages
  • What Is a PL/SQL Package?
  • Modularizing for Maintainable Packages
  • Generating a package
  • access to elements : Access to Package Elements
  • building : Building Packages
  • built-in : Builtin Packages
  • codependency : Creating Codependent Packages
  • effective coding of : Best Practices for Packages
  • exception : (see PLVexc packages)
  • exception section : The exception section
  • flexibility : Building Flexibility Into Your Packages
  • generating : Generating a Package
  • help : (see documentation)
  • hiding elements of
  • • Enforced Information Hiding
    • Building Windows Into Your Packages
    • Hiding Package Data
  • in PL/Vision
  • • PL/Vision Package Bundles
    • Creating the PL/Vision Packages
    • PL/Vision Package Specifications
  • initializing
  • • The Initialization Section
    • Asserting the purity level of the initialization section
  • interface
  • • Constructing the Optimal Interface to Your Package
    • Simplifying Package Interfaces
  • layering : Modularizing for Maintainable Packages
  • memory architecture : The Memory-Resident Architecture of Packages
  • memory requirements : Storage Requirements
  • multiple, constructing : Simultaneous Construction of Multiple Packages
  • naming : Selecting Package Names
  • online help : (see PLVhlp package)
  • ordering elements of : Choosing the Order of Elements
  • package body
  • • Building Packages
    • The Package Body
  • package specification
  • • The Package Specification
    • Building Packages
  • PL/SQL : Declarative Developing in PL/SQL
  • PLVctlg table : PLVctlg table
  • recompiling : Organizing Package Source Code
  • referencing elements of : Referencing Package Elements
  • synonyms for : Granting Access to PL/Vision
  • windows in : Building Windows Into Your Packages
  • working with large : Working with Large Packages
• page size
• • Setting the Page Size
  • Maintaining the current page variables
  • online help : Setting the page size
• pagesize function : Setting the Page Size
• paragraphs
• • Wrapping long strings into paragraphs
  • Wrapping Strings into Paragraphs
• parallelization of programs : Leveraging builtin packages
• parameter list : procedure with parameter list and executable code
• PARSE procedure : Open and parse
• parse tree : Working with Large Packages
• parse_delete procedure
• • Bundled, low-level operations
  • Parse for delete
• parse_name procedure
• • Miscellaneous operations
  • Parsing the File Name
• parsing
• • code : PLVprsps: PL/SQL Source Code Parsing
  • delimiter, defining : Customizing the Delimiter Set
  • file name : Parsing the File Name
  • PL/SQL code : Parsing PL/SQL Code
  • program names : Converting the Program Name
  • strings
  • • PLVlex: Lexical Analysis
    • PLVprs: String Parsing
    • PLVprs, PLVtkn, and PLVprsps: Parsing Strings
• partial installation : Warning About Partial Installation
• pauding programs : Miscellaneous programs
• pause procedure
• • Miscellaneous programs
  • Pausing Your Program
• pausing help text (see more procedure)
• pausing programs
• • Pausing Your Program
  • Builtin Packages
• perform_commit procedure
• • Performing commits
  • The COMMIT Substitute
• perform_rollback function
• • Performing rollbacks
  • Performing Rollbacks
• performance
• • Builtin Packages
  • Performance Improvement
  • Choosing the Best Performer
  • Calibration and timing scripts
  • PLVtmr: Analyzing Program Performance
  • dynamic PL/SQL : The overhead of dynamic PL/SQL
  • package size : Working with Large Packages
• permissions : (see access)
• persistence
• • Object Persistence
  • Need global data structures for your PL/SQL programs
• pinning code into memory : Managing packages in shared memory
• pkg procedure
• • Generating a package
  • Generating a Package
• pky procedure : Dumping the DDL
• PL/SQL
• • call stack : Accessing the PL/SQL Call Stack
  • code, parsing : Parsing PL/SQL Code
  • declarative developing : Declarative Developing in PL/SQL
  • dynamic code : Executing Dynamic PL/SQL Code
  • objects : PLVobj: A Packaged Interface to ALL_OBJECTS
  • performance and : The overhead of dynamic PL/SQL
  • reserved words : PLVtkn: Token Table Interface
  • source code repositories : PLVio: Reading and Writing PL/SQL Source Code
  • tokens : (see reserved words)
• PL/Vision : What Is PL/Vision?
• • bindobj procedure in : Using bindobj in PL/Vision
  • cataloging : Cataloguing PL/Vision
  • enhancing PLVexc with : Revamping the PLVexc Package
  • installing : Installation Instructions
  • logging : (see logging)
  • loopexec procedure in : Applying loopexec in PL/Vision
  • packages of
  • • PL/Vision Package Bundles
    • Creating the PL/Vision Packages
    • PL/Vision Package Specifications
  • PLVgen and : Leveraging PL/Vision in PLVgen
  • PLVmsg with : Using PLVmsg in PL/Vision
  • sharing among users : Granting Access to PL/Vision
  • tracing : (see tracing)
• PL/Vision Lite : PL/Vision Package Bundles
• placeholder function : Miscellaneous programs
• plsql procedure
• • Dumping the DDL
  • Executing dynamic PL/SQL
  • Executing Dynamic PL/SQL Code
• plsql_block function
• • Miscellaneous programs
  • Implementation of PLVdyn.plsql
• plsql_delimiters constant
• • Package constants
  • Customizing the Delimiter Set
• plsql_identifier variable
• • Anchoring datatypes
  • The Predefined Datatypes
  • Scope of a dynamic PL/SQL block
• plsql_string procedure
• • Parsing PL/SQL source code
  • plsql_string procedure
• plug-and-play packages
• • Plug-and-Play Components
  • PLVdyn and PLVfk: Dynamic SQL and PL/SQL
• PLV package : Building Blocks
• • constants and functions : PLV: Top-Level Constants and Functions
• PLV_token table : Keeping Track of PL/SQL Keywords
• PLVcase package
• • Developer Utilities
  • PLVcase: PL/SQL Code Conversion
  • PLVcase: Converting the Case of PL/SQL Programs
• PLVcat package
• • Developer Utilities
  • PLVcat: PL/SQL Code Cataloguing
  • Selecting Token Types for Parsing
  • PLVcat: Cataloguing PL/SQL Source Code
  • references and dependencies : Identifying References and Dependencies
• plvcat.sql script : Cataloguing PL/Vision
• PLVchar package : Building Blocks
• PLVchr package : PLVchr: Operations on Single Characters
• PLVcmt package
• • Plug-and-Play Components
  • PLVcmt: Commit Processing
  • PLVcmt: Enhancing Commit Processing
  • Using put_line
• PLVctlg table : The PLVcat Database Tables
• PLVddd package
• • Developer Utilities
  • PLVddd: DDL Syntax Dump
• PLVdyn package
• • Building Windows Into Your Packages
  • Plug-and-Play Components
  • Special Handling for PLVdyn
  • PLVdyn: Dynamic SQL Operations
  • PLVdyn: A Code Layer over DBMS_SQL
  • compiling code with : Compiling source code with PLVdyn
  • displaying table contents : Displaying a Table
  • schemas and : Executing PLVdyn in Different Schemas
• PLVdyn1 package : Plug-and-Play Components
• PLVexc package
• • Plug-and-Play Components
  • PLVexc: Exception Handling
  • Using the PLVexc Exception Handler
  • About Plug-and-Play
  • Using put_line
  • Exception Handling
  • enhancing with PL/Vision : Revamping the PLVexc Package
  • PLVlog package and : Leveraging PLVLog
  • PLVmsg with : Integrating PLVmsg with Error Handling
  • PLVtrc package and : Integrating PLVexc with PLVtrc
• PLVfile package
• • Building Blocks
  • PLVfile: Operating System I/O Manager
  • PLVfile: Reading and Writing Operating System Files
• PLVfk package
• • Plug-and-Play Components
  • PLVfk: Foreign Key Interface
  • PLVfk: Generic Foreign Key Lookups
• PLVgen package
• • Using Effective Coding Style for Packages
  • Toggles for Code Generation
  • Developer Utilities
  • PLVgen: PL/SQL Code Generator
  • PLVgen: Generating PL/SQL Programs
  • overloading in : Overloading in PLVgen
• plvgrant.sql script : Granting Access to PL/Vision
• PLVhlp : Developer Utilities
• PLVhlp package : Common Package Elements
• PLVhlp package
• • Installing Online Help for PL/Vision
  • Using Online Help
  • PLVhlp: Online Help Architechture
  • Why PLVio?
  • Generating help text stubs
  • PLVhlp: Online Help for PL/SQL Programs
• plvins23.sql script : Creating the PL/Vision Packages
• plvinst.sql script : Creating the PL/Vision Packages
• PLVio package
• • Building Blocks
  • PLVio: Input/Output Processing
  • PLVio: Reading and Writing PL/SQL Source Code
  • PLVhlp package and : Constructing an Online Help Package
• PLVlex package
• • Building Blocks
  • PLVlex: Lexical Analysis
• PLVlog package
• • Changing Package Behavior Without Changing the Application
  • Plug-and-Play Components
  • PLVlog: Logging Facility
  • PLVlog: Logging Activity in PL/SQL Programs
  • PLVexc package and
  • • Logging errors
    • Leveraging PLVLog
  • rollbacks : Rolling Back with PLVlog
• PLVlst package
• • Building Blocks
  • PLVlst: List Manager
• PLVmsg package
• • Building Blocks
  • PLVmsg: Message Handling
  • PLVmsg: Single-Sourcing PL/SQL Message Text
  • Defining error messages with PLVmsg
• PLVobj package
• • Building Blocks
  • PLVobj: Object Interface
  • PLVobj: A Packaged Interface to ALL_OBJECTS
• PLVprs package
• • Building Blocks
  • PLVprs: String Parsing
  • PLVprs: Useful String Parsing Extensions
• PLVprsps : Building Blocks
• PLVprsps package : PLVprsps: Parsing PL/SQL Strings
• plvpsyn.sql script : Granting Access to PL/Vision
• PLVrb package
• • Plug-and-Play Components
  • PLVrb: Rollback Processing
  • PLVrb: Performing Rollbacks
• PLVrfrnc table : Examining the references
• PLVstk package
• • Building Blocks
  • PLVstk: Stack Manager
• PLVtab package
• • Building Flexibility Into Your Packages
  • Supporting many data combinations
  • Building Blocks
  • PLVtab: Table Interface
  • PLVtab: Easy Access to PL/SQL Tables
• PLVtkn package
• • Building Blocks
  • PLVtkn: Token Table Interface
  • PLVtkn: Managing PL/SQL Tokens
• PLVtmr package
• • Developer Utilities
  • PLVtmr: Program Performance Analyzer
  • PLVtmr: Analyzing Program Performance
  • Generating a Timer Script
  • Examining the catalogue
  • The overhead of dynamic PL/SQL
• PLVtrc package
• • Plug-and-Play Components
  • PLVtrc: Trace Facility
  • Using the Program Trace
  • PLVtrc: Tracing Execution of PL/SQL Programs
  • PLVexc package and : Integrating PLVexc with PLVtrc
• PLVvu package
• • Developer Utilities
  • PLVvu: Code and Error Viewing
  • PLVvu: Viewing Source Code and Compile Errors
  • Current Sources of Information
• pop procedure : Modifying stack contents
• post-insert savepoint : Setting the post-insert savepoint
• pragmas : RESTRICT_REFERENCES pragma
• • EXCEPTION_INIT : Package-based exceptions
• prebuilt packages : Prebuilt Packages
• predefined exceptions : Impact of Predefined Exceptions
• prefix table row value : Setting the Display Prefix
• prefix function
• • Setting the line prefix
  • Setting the row prefix
• prefixes to package element names : Avoiding Superfluous Naming Elements
• prependitem procedure : Modifying list contents
• prevmod function
• • Tracing PL/SQL code execution
  • Previous module
• private PL/Vision package synonyms : Granting Access to PL/Vision
• private elements
• • Public and private data
  • Building Windows Into Your Packages
  • Hiding Package Data
  • declaring before public : Choosing the Order of Elements
  • package elements
  • • Enforced Information Hiding
    • Access to Package Elements
• privileges, DDL execution : DDL Operations
• proc procedure
• • Generating a procedure
  • Generating a Procedure
  • Implementing the Procedure Generator
• procedures : (see functions)
• • execute authority : Guaranteeing Transaction Integrity
  • generating
  • • Generating a Procedure
    • Implementing the Procedure Generator
  • help : Generating a help procedure
• process_halted exception
• • Package-based exceptions
  • Bailing Out with PLVexc
  • Package-Based Exceptions
• productivity : The Benefits of PL/Vision
• developing technique
• • Appendix: PL/SQL Exercises
  • The Iceberg Approach to Coding
  • numinstr function
  • analyzing performance : (see performance)
  • avoiding hard-coded literals : Obliterating the Literals
  • avoiding redundancy : (see redundancy)
  • backward compatibility
  • • Supplying Backward Compatibility
    • Don't Forget Backward Compatibility
  • coding packages : Best Practices for Packages
  • consistent error data : Recording consistent error data
  • cover package : Working with Large Packages
  • declarative developing : Declarative Developing in PL/SQL
  • handling exceptions : Analyzing the Need
  • handling fatal errors : Bailing Out with PLVexc
  • hard-coded transaction processing : Who Needs PLVcmt?
  • logging : (see logging)
  • modularizing : Modularizing for Maintainable Packages
  • object-oriented design : Object-Oriented Design
  • overloading : When to Overload
  • simultaneous package construction : Simultaneous Construction of Multiple Packages
  • testing/debugging : The test/debug cycle in PL/SQL
  • toggles : Toggling Package Behavior
  • top-down design : Top-Down Design
  • user interface : Improving the User Interface
  • using package initialization section : When to use the initialization section
  • using packages : When Should You Build a Package?
  • windows : Building Windows Into Your Packages
• programs : (see code)
• ps2db procedure
• • Managing the log
  • Transferring a PL/SQL table log to a database table
• ps_callstack function
• • Accessing the PL/SQL call stack
  • Accessing the PL/SQL Call Stack
• ps_module function
• • Accessing the PL/SQL call stack
  • Accessing the PL/SQL Call Stack
• psformat procedure : The Origins of PL/Vision
• pstab constant : PL/Vision constants
• pstab2file procedure
• • Copying a file
  • Copying PL/SQL Table to File
• pstab_count function
• • Managing the log
  • Counting and clearing the PL/SQL table
• public PL/Vision package synonyms : Granting Access to PL/Vision
• public data package elements : Access to Package Elements
• public elements
• • Public and private data
  • Building Windows Into Your Packages
  • Hiding Package Data
  • When to Make Data Public
  • anchored declarations : Anchoring to Public Variables
  • declaring before private : Choosing the Order of Elements
  • package elements
  • • Enforced Information Hiding
    • The Package Specification
• purity levels : RESTRICT_REFERENCES pragma
• push procedure : Modifying stack contents
• PUT_LINE package
• • (see also package)
  • A Powerful Substitute for DBMS_OUTPUT
  • a DBMS_OUTPUT Substitute
• put_line procedure
• • Writing to a file
  • Reading and writing lines
  • Writing to the log
  • Writing to the Target
  • Writing to a File
  • put_line Procedure
  • Writing to the Log
  • specifying rollbacks : Specifying rollbacks when calling put_line
• PUT_LINE procedure : Supporting many data combinations
• put_line repository : Displaying the Target Repository