
Symbols
| A
| B
| C
| D
| E
| F
| G
| H
| I
| J
| K
| L
| M
| N
| O
| P
| Q
| R
| S
| T
| U
| V
| W
| Y
| Z
Index: C
- calendar
: (see date)
- case
- 
  - consistency of
: 22.7.4. Ensure Case Consistency of Parameters
  - INITCAP function
: 11.1.4. The INITCAP function
  - LOWER function
: 11.1.7. The LOWER function
  - and readability
: 3.1.2. Using Case to Aid Readability
  - sensitivity
  
- 
    - 2.1. The PL/SQL Character Set
    - 2.3. Literals
  
 
- UPPER function
: 11.1.16. The UPPER function
 
- CAST procedure
- 
  - object views and
: 20.1. Example: Using Object Views
 
- CAST pseudo-function
: 19.5.2. The CAST Pseudo-function
- casting collections
: 19.5.2.1. Casting a named collection
- CDE
: (see Cooperative Development Environment)
- CEIL (ceiling) function
: 13.1.6. The CEIL function
- century
: (see date)
- CHANGE procedure
: C.5.2. The CHANGE procedure
- CHAR datatype
- 
  - 2.3. Literals
  - 4.2.3.1. The CHAR datatype
  - converting to VARCHAR2
: 4.2.3.2. The VARCHAR2 and VARCHAR datatypes
  - converting to/from ROWID
  
- 
    - 14.2.1. The CHARTOROWID function
    - 14.2.5. The ROWIDTOCHAR function
  
 
- with LENGTH function
: 11.1.6. The LENGTH function
 
- character datatypes,
in overloaded modules
: 15.8.4. Restrictions on Overloading
- character functions
: 11. Character Functions
- character sets
: 14.2.2. The CONVERT function
- characters
- 
  - adding to strings
: 11.1.11. The RPAD function
  - converting to numbers, package for
: 17.8.7. Recursive Processing in a SQL Statement
  - datatypes for
: 4.2.3. Character Datatypes
  - extracting from strings
: 11.1.14. The SUBSTR function
  - NLS datatypes for
: 4.2.6. NLS Character Datatypes
  - replacing in strings
  
- 
    - 11.1.10. The REPLACE function
    - 11.1.15. The TRANSLATE function
  
 
- stripping from strings
  
- 
    - 11.1.12. The RTRIM function
    - 11.1.9. The LTRIM function
  
 
- word wrap
: 11.2.2. Implementing Word Wrap for Long Text
 
- CHARSETFORM property
: 21.4.3.4. CHARSETID and   CHARSETFORM properties
- CHARSETID property
: 21.4.3.4. CHARSETID and   CHARSETFORM properties
- CHARTOROWID function
: 14.2.1. The CHARTOROWID function
- checking for NULL values
: 4.3.2. Checking for NULL Values
- child block
: (see nested blocks)
- child records
: (see records)
- CHR function
: 11.1.2. The CHR function
- class instances
: 18.1.4.2. Classification 
- classes
: (see object types)
- classification of objects
: 18.1.4.2. Classification 
- clearing tables
: 10.7. Clearing the PL/SQL Table
- client-side SQL
: 25.3.3. Avoid Client-Side SQL
- CLOB datatype
- 
  - 1.4.7.6. Large object support
  - 4.2.7.3. The CLOB datatype
  - EMPTY_CLOB function
: 13.2.3. The EMPTY_CLOB function
 
- clock
: (see time)
- CLOSE statement
- 
  - (see also cursors)
  - 6.2.2. Cursor Operations
  - 6.8. Closing Cursors
 
- CLOSE_CURSOR procedure
: C.14.3. The CLOSE_CURSOR procedure
- CLOSE_DATABASE_LINK procedure
: C.12.1. The CLOSE_DATABASE_LINK procedure
- closing cursors
: 6.8. Closing Cursors
- code
- 
  - compiled, tuning access to
: 25.2. Tuning Access to Compiled Code
  - critical, pinning into SGA
: 25.2.2. Pin Critical Code into the SGA
  - encrypting
: 23.7. Encrypting Stored Code
  - memory-based architecture
: 23.1.3. Memory-Based Architecture of PL/SQL Code 
  - procedural, avoiding
: 25.3.5. Avoid Procedural Code When Possible  
  - repetetive
: (see redundancy)
  - reusing
: 1.7.1. Write as Little Code as Possible
  - shared, executing
: 23.1. Executing Stored Code
  - structuring of
: 1.7.5. Structured Code and Other Best Practices
  - style of
: 1.7.4. Standardize Your PL/SQL Development Environment
  - testing
: 24.2.5. Change and Test One Area of Code at a Time
 
- coding
: 1.2. The Concept of Programming in Oracle Applications
- 
  - analyzing size of
: 23.6.3. Analyzing the Size of PL/SQL Code
  - anticipating errors
: (see exceptions)
  - avoiding repetitive
: 22.3. Take Full Advantage of Local Modularization
  - comments in
: (see comments)
  - considering parameter case
: 22.7.4. Ensure Case Consistency of Parameters
  - creating independent modules
: 22.5. Create Independent Modules
  - cross-referencing source code
: 23.6.5. Cross-Referencing Source Code
  - in databases
: 23. Managing Code in the Database
  - documenting
: 24.2.6. Document and Back Up Your Efforts
  - errors
: (see errors; exceptions)
  - finding strings in
: 23.6.4. Displaying and Searching Source Code
  - hints for effective
  
- 
    - 1.5. Advice for Oracle Programmers
    - 3. Effective Coding Style
    - 4.2.8.3. Drawbacks of implicit conversions
    - 22. Code Design Tips
    - commenting
: 3.6. Using Comments Effectively
    - exception handling
: 8.10. RAISE Nothing but Exceptions
    - IF statements
: 5.1.4. Nested IF Statements
    - loops
: 7.7. Tips for PL/SQL Loops
    - nested records
: 9.7.1. Example of Nested Records
    - parameters
: 22.7. Tips for Parameter Design
    - records
: 9.1.3.3. Leaner, cleaner code
  
 
- increasing readability of code
: 5.2.2.1. Improving the readability of your program 
  - layout of
: 3.1. Fundamentals of Effective Layout
  - recursive processing
: 17.8.7. Recursive Processing in a SQL Statement
  - removing unused variables
: 4.7.6. Remove Unused Variables from Programs
  - sequential processing
: 17.8.6. Sequential Processing Against a Column's Value
  - simplifying logic with variables
: 4.7.9. Use Variables to Hide Complex Logic
  - testing programs
: 2.5.2. Multiline Comment Syntax
 
- collections
- 
  - adding/removing elements from
: 19.4.3. Adding and Removing Elements
  - built-in methods for
: 19.6. Collection Built-Ins
  - casting
: 19.5.2.1. Casting a named collection
  - choosing which kind to use
: 19.9. Which Collection Type Should I Use?
  - collection variables
  
- 
    - 19.2.2.1. Collection variables
    - 19.4.1. Initializing Collection Variables
  
 
- comparing
: 19.4.4. Comparing Collections
  - creating
: 19.2. Creating the New Collections
  - data dictionary entries for
: 19.8.2. Data Dictionary
  - declaring as datatype
: 19.2.2. Collections in PL/SQL
  - index-by tables
: (see index-by tables)
  - nested tables
: (see nested tables)
  - passing arguments of
: 19.8.3. Call by Reference or Call by Value
  - PL/SQL-to-server integration example
: 19.7. Example: PL/SQL-to-Server Integration
  - privileges
: 19.8.1. Privileges
  - pseudo-functions
: 19.5. Collection Pseudo-Functions
  - types of
: 19.1. Types of Collections
  - VARRAYs
: (see VARRAYs)
 
- COLUMN_VALUE procedure
: C.14.4. The COLUMN_VALUE procedure
- columns
- 
  - (see also records)
  - 9.1.1. Different Types of Records
  - abbreviations for
: 3.2. Formatting SQL Statements
  - aliases for
  
- 
    - 3.2. Formatting SQL Statements
    - 6.7. Column Aliases in Cursors
    - 9.3.2. Setting the Record's Column Names
  
 
- BFILE, initializing
: 13.2.1. The BFILENAME function
  - choosing for cursor-based record
: 9.3.1. Choosing Columns for a Cursor Record
  - collections as
: 19.2.1.1. Collection as a "column" in a conventional table
  - collections as datatypes for
: 19.1. Types of Collections
  - names for
: 1.7.5. Structured Code and Other Best Practices
  - naming procedure
: 17.6. Column/Function Name Precedence
  - objects for
: 18.1.2. Some Simple Examples
  
- 
    - VALUE operator with
: 18.4.2.3. VALUE
  
 
- partial values of
: 17.8.5. GROUP BY Partial Column Values
  - represented by variables
: 4.7.7. Use %TYPE When a Variable Represents a Column
  - sequential processing against value
: 17.8.6. Sequential Processing Against a Column's Value
  - synchronization with
: 4.5.1.1. Synchronization with database columns
  - where OIDS are stored
: 18.4.2.1. Object identifiers (OIDs)
 
- COMMA_TO_TABLE procedure
: C.16.2. The  COMMA_TO_TABLE procedure
- COMMENT keyword
: 6.1.1. The COMMIT Statement
- comments
: 2.5. Comments
- 
  - associated with transactions
: 6.1.1. The COMMIT Statement
  - describing parameters
: 22.7.1. Document All Parameters and Their Functions
  - encrypted code and
: 23.7.3. Impact of Encrypting Code
  - symbols for
: 2.1. The PL/SQL Character Set
  - using effectively
: 3.6. Using Comments Effectively
 
- COMMIT procedure
- 
  - (see also DBMS_PIPE)
  - C.10. DBMS_PIPE
  - C.15.4. The  COMMIT procedure 
 
- COMMIT statement
- 
  - 6.1.1. The COMMIT Statement
  - 6.11.1. Releasing Locks with COMMIT
 
- COMMIT_COMMENT procedure
: C.15.5. The  COMMIT_COMMENT procedure 
- COMMIT_FORCE procedure
: C.15.6. The  COMMIT_FORCE procedure
- Companion Utilities Guide
: A. What's on the Companion Disk?
- COMPARE function
: C.6.2. The  COMPARE function
- comparing
- 
  - collections
: 19.4.4. Comparing Collections
  - with NULL
: 4.3. NULLs in PL/SQL
  - objects
: 18.3.6. Comparing Objects
  - records
: 9.1.6. Comparing Two Records
  - strings
  
- 
    - 4.2.3.2. The VARCHAR2 and VARCHAR datatypes
    - 11.1.13. The SOUNDEX function
  
 
 
- comparison methods
: 18.3.1. About Object Types
- compilation
- 
  - automatic
: 23.3.1. Interdependencies of Stored Objects
  - errors, viewing
: 23.5.4. Viewing Compilation Errors in SQL*Plus
  - manual
: 23.3.1. Interdependencies of Stored Objects
  - of modules
: 4.5.2. Anchoring at Compile Time
 
- COMPILE_SCHEMA procedure
: C.16.3. The  COMPILE_SCHEMA procedure
- compiler constructs
: (see pragmas)
- compiling
- 
  - forced
: 20.7.3. Forcing Compilation
  - package specifications
: 1.7.3. Center All Development Around Packages
 
- compound symbols
: (see symbols)
- CONCAT function
- 
  - 4.3.3. Function Results with NULL Arguments
  - 11.1.3. The CONCAT function
 
- concatenation (||) operator
- 
  - 4.3.3. Function Results with NULL Arguments
  - 11.1.3. The CONCAT function
 
- concatenation, string
- 
  - 4.3.3. Function Results with NULL Arguments
  - 11.1.3. The CONCAT function
 
- conditional control structures
: 5. Conditional and Sequential Control
- 
  - formatting
: 3.3. Formatting Control Structures
 
- conditional loops
: (see loops)
- constants
: (see literals; named constants; variables)
- constrained datatypes
- 
  - 4.4.1. Constrained Declarations
  - 4.6. Programmer-Defined Subtypes
  - 4.6.3. Emulating Constrained Subtypes
 
- constructor methods
- 
  - 18.2.2.1. PL/SQL usage 
  - 18.3.1. About Object Types
  - 18.4.1.1. Constructors
 
- constructors,
initializing collections
: 19.4.1.1. Initializing with a constructor
- control structures,
iterative
: (see loops)
- conventions, naming
: 4.7.1. Establish Clear Variable Naming Conventions 
- conversion
- 
  - and format models
: 14.1. Conversion Formats
  - functions for
: 14. Conversion Functions
  - implicit
: 14. Conversion Functions
 
- CONVERT function
- 
  - C.7.2. The CONVERT function
  - 14.2.2. The CONVERT function
 
- converting
- 
  - between datatypes
: 4.2.8. Conversion Between Datatypes
  - datatypes
  
- 
    - external procedures and
: 21.4.1. Datatype Conversion
    - performance and
: 25.4.7. Avoid Type Conversions When Possible
  
 
- explicitly versus implicitly
: 4.2.8.1. Explicit data conversions
  - to/from hexadecimal
: 14.2.3. The HEXTORAW function
  - to row numbers
: 10.5.1. Automatic Conversion of Row Number Expressions
  - triggers to procedures
: 25.3.7. Keep Database Triggers Small
  - variables to named constants
: 4.7.5. Convert Variables into Named Constants 
 
- Cooperative Development Environment (CDE)
: 1.2. The Concept of Programming in Oracle Applications
- COPY procedure
: C.6.3. The  COPY procedure
- correlated subqueries
: 17.8.3. Replacing Correlated Subqueries
- correlation variables
: 18.4.2.2. REFs
- COS function
: 13.1.7. The COS function
- COSH function
: 13.1.8. The COSH function
- COUNT function
- 
  - 10.8.2.1. The COUNT function
  - 19.6.1. COUNT
 
- counted loops
: (see numeric FOR loops)
- counting substring occurrences
: 11.2.4. Counting Substring Occurrences in Strings
- CREATE command
: 23.5.1. Creating Stored Objects
- CREATE DIRECTORY command
: 4.2.7.7. Working with BFILEs
- CREATE LIBRARY command
- 
  - 21.2.3. Step 3: Issue CREATE LIBRARY Statement
  - 21.3.1. CREATE LIBRARY: Creating the External Procedure Library
 
- CREATE OR REPLACE command
: 23.5.3. Changing Stored Objects
- CREATE TYPE BODY statement
: 18.3.3. CREATE TYPE BODY: Creating a Body
- CREATE TYPE command
: 19.2. Creating the New Collections
- 
  - CREATE TYPE ... AS OBJECT statement
: 19.2.1.2. Collection as an attribute of an object type
 
- CREATE TYPE statement
: 18.3.2. CREATE TYPE and DROP TYPE: Creating and Dropping Types
- CREATE VIEW statement
: 20.3.1. CREATE VIEW: Creating an Object View
- CREATE_QUEUE procedure
: C.3.2.3. The  CREATE_QUEUE procedure
- CREATE_QUEUE_TABLE procedure
: C.3.2.1. The  CREATE_QUEUE_TABLE procedure
- cursor FOR loops
: 7.4. The Cursor FOR Loop
- 
  - formatting
: 3.3.2. Formatting Loops
  - premature termination of
: 7.7.2.1. Premature FOR loop termination
  - records in
: 7.4.2. The Cursor FOR Loop Record
  - scope of
: 7.6.2.1. Scope in FOR loops
 
- CURSOR statement
: 6.4. Declaring Cursors
- cursor variables
- 
  - aliases for
: 6.12.6.3. Cursor variable aliases
  - as arguments
: 6.12.7. Passing Cursor Variables as Arguments
  - attributes of
: 6.12.2. Similarities to Static Cursors
  - scope of
: 6.12.6.4. Scope of cursor object
 
- CURSOR_ALREADY_OPEN exception
: 8.3.1. Named System Exceptions 
- cursors
: 6.2. Cursors in PL/SQL
- 
  - attributes of
: 6.9. Cursor Attributes
  
- 
    - for cursor variables
: 6.12.2. Similarities to Static Cursors
    - %FOUND
: 6.9.1. The %FOUND Attribute
    - %ISOPEN
    
- 
      - 6.5. Opening Cursors
      - 6.9.4. The %ISOPEN Attribute
    
 
- %NOTFOUND
    
- 
      - 6.6.2. Fetching Past the Last Row
      - 6.9.2. The %NOTFOUND Attribute
    
 
- %ROWCOUNT
: 6.9.3. The %ROWCOUNT Attribute
  
 
- closing
: 6.8. Closing Cursors
  - column aliases in
: 6.7. Column Aliases in Cursors
  - corresponding to records
: 9.1.4. Guidelines for Using Records
  - cursor variables
  
- 
    - 1.4.5.2. Cursor variables
    - 6.2.1. Types of Cursors
    - 6.12. Cursor Variables
    - restrictions on
: 6.12.8. Cursor Variable Restrictions
  
 
- database access based on
: 1.4.3.8. Cursor-based access to the database
  - declaring
: 6.4. Declaring Cursors
  
- 
    - in packages
: 16.3.2. Declaring Package Cursors
  
 
- examples of using
: 6.13. Working with Cursors 
  - explicit
  
- 
    - 1.7.4. Standardize Your PL/SQL Development Environment
    - 6.2.1. Types of Cursors
    - 6.3.3. Explicit Cursors
    - FETCH INTO from
: 9.5.3. FETCH INTO from an Explicit Cursor
  
 
- explicit, fetching from
: 1.7.2. Synchronize Program and Data Structures
  - fetching from
: 6.6. Fetching from Cursors
  - FOR loops for
  
- 
    - 1.6.4. The cursor FOR loop
    - 1.7.1. Write as Little Code as Possible
  
 
- group functions in
: 6.13.1.1. Inefficiency of group functions in cursors
  - identifier precedence
: 6.4.3. Identifier Precedence in a Cursor
  - implicit
  
- 
    - 1.7.4. Standardize Your PL/SQL Development Environment
    - 6.2.1. Types of Cursors
    - 6.3.1. Implicit Cursors
    - 6.9. Cursor Attributes
    - 6.9.5. Implicit SQL Cursor Attributes
    - SELECT INTO from
: 9.5.2. SELECT INTO from an Implicit Cursor
  
 
- naming
: 6.4.1. The Cursor Name
  - opening
  
- 
    - 6.2.2. Cursor Operations
    - 6.5. Opening Cursors
    - 6.10.2. Opening Cursors with Parameters
  
 
- parameters of
: 6.10. Cursor Parameters
  - records based on
: 9.3. Cursor-Based Records
  - RETURN statement
: 6.4.4. The Cursor RETURN Clause
  - scope of
: 15.3.5.4. Cursor scope
  - SELECT FOR UPDATE statement
: 6.11. SELECT FOR UPDATE in Cursors
  - specifying in packages
: 16.3. The Package Specification
  - static
: 6.2.1. Types of Cursors
  - variables in
: 6.4.2. PL/SQL Variables in a Cursor
 
Symbols
| A
| B
| C
| D
| E
| F
| G
| H
| I
| J
| K
| L
| M
| N
| O
| P
| Q
| R
| S
| T
| U
| V
| W
| Y
| Z
 
Copyright (c) 2000 O'Reilly & Associates. All rights reserved.