Online Help

Oracle Raptor
Online Help
Release 1.0 Early Adopter
December 2005
This is a single PDF document containing the online help
topics for Oracle Raptor. It is provided merely as a
convenience; you are still encouraged to use the help within
the Raptor user interface to obtain immediate and
context-relevant information.
Raptor Online Help, Release 1.0 Early Adopter
Copyright 2005, Oracle. All rights reserved.

Primary Author:
Chuck Murray
The Programs (which include both the software and documentation) contain proprietary information; they
are provided under a license agreement containing restrictions on use and disclosure and are also protected
by copyright, patent, and other intellectual and industrial property laws. Reverse engineering, disassembly,
or decompilation of the Programs, except to the extent required to obtain interoperability with other
independently created software or as specified by law, is prohibited.
The information contained in this document is subject to change without notice. If you find any problems in
the documentation, please report them to us in writing. This document is not warranted to be error-free.
Except as may be expressly permitted in your license agreement for these Programs, no part of these
Programs may be reproduced or transmitted in any form or by any means, electronic or mechanical, for any
purpose.
If the Programs are delivered to the United States Government or anyone licensing or using the Programs on
behalf of the United States Government, the following notice is applicable:
U.S. GOVERNMENT RIGHTS Programs, software, databases, and related documentation and technical data
delivered to U.S. Government customers are "commercial computer software" or "commercial technical data"
pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As
such, use, duplication, disclosure, modification, and adaptation of the Programs, including documentation
and technical data, shall be subject to the licensing restrictions set forth in the applicable Oracle license
agreement, and, to the extent applicable, the additional rights set forth in FAR 52.227-19, Commercial
Computer SoftwareRestricted Rights (June 1987). Oracle Corporation, 500 Oracle Parkway, Redwood City,
CA 94065
The Programs are not intended for use in any nuclear, aviation, mass transit, medical, or other inherently
dangerous applications. It shall be the licensee's responsibility to take all appropriate fail-safe, backup,
redundancy and other measures to ensure the safe use of such applications if the Programs are used for such
purposes, and we disclaim liability for any damages caused by such use of the Programs.
Oracle, JD Edwards, PeopleSoft, and Retek are registered trademarks of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective owners.
The Programs may provide links to Web sites and access to content, products, and services from third
parties. Oracle is not responsible for the availability of, or any content provided on, third-party Web sites.
You bear all risks associated with the use of such content. If you choose to purchase any products or services
from a third party, the relationship is directly between you and the third party. Oracle is not responsible for:
(a) the quality of third-party products or services; or (b) fulfilling any of the terms of the agreement with the
third party, including delivery of products or services and warranty obligations related to purchased
products or services. Oracle is not responsible for any loss or damage of any sort that you may incur from
dealing with any third party.
Contents
1
Raptor Concepts and Usage

1.1
1.1.1
1.2
1.2.1
1.2.2
1.2.3
1.2.4
1.2.5
1.2.6
1.2.7
1.2.8
1.2.9
1.2.10
1.2.11
1.2.12
1.2.13
1.2.14
1.2.15
1.3
1.4
1.5
1.6
1.6.1
1.6.2
1.6.3
1.7
1.8
1.9
1.9.1
1.9.2
1.9.3
1.9.4
1.9.5
1.9.6
1.9.7
Raptor User Interface.................................................................................................................. 1-1

Menus for Raptor................................................................................................................. 1-4
Database Objects ......................................................................................................................... 1-5
Database Links ..................................................................................................................... 1-6
Functions............................................................................................................................... 1-6
Indexes................................................................................................................................... 1-6
Materialized Views.............................................................................................................. 1-7
Materialized View Logs ...................................................................................................... 1-7
Packages ................................................................................................................................ 1-7
Procedures ............................................................................................................................ 1-7
Recycle Bin............................................................................................................................ 1-8
Sequences .............................................................................................................................. 1-8
Synonyms (Public and Private) ......................................................................................... 1-8
Tables..................................................................................................................................... 1-8
Triggers .............................................................................................................................. 1-10
Types................................................................................................................................... 1-10
Users (Other Users) .......................................................................................................... 1-10
Views .................................................................................................................................. 1-10
Database Connections ............................................................................................................. 1-11
Entering and Modifying Data ................................................................................................ 1-12
Running and Debugging Functions and Procedures ......................................................... 1-13
Using the SQL Worksheet....................................................................................................... 1-15
SQL*Plus Statements Supported and Not Supported in SQL Worksheet................ 1-16
Script Runner..................................................................................................................... 1-17
Execution Plan................................................................................................................... 1-18
Using SQL*Plus ........................................................................................................................ 1-18
Using Snippets to Insert Code Fragments............................................................................ 1-19
Reports....................................................................................................................................... 1-20
About Your Database reports ......................................................................................... 1-21
Database Administration reports ................................................................................... 1-21
Table reports...................................................................................................................... 1-21
PL/SQL reports................................................................................................................. 1-23
Security reports ................................................................................................................. 1-23
XML reports....................................................................................................................... 1-24
Jobs reports ........................................................................................................................ 1-24
iii
1.9.8
Streams reports .................................................................................................................
1.9.9
All Objects reports ............................................................................................................
1.9.10
Data Dictionary reports ...................................................................................................
1.9.11
User Defined reports ........................................................................................................
1.10
Raptor Preferences ...................................................................................................................
1.10.1
Environment ......................................................................................................................
1.10.2
Accelerators .......................................................................................................................
1.10.3
Code Editor........................................................................................................................
1.10.4
Database Connections ......................................................................................................
1.10.5
Debugger............................................................................................................................
1.10.6
Documentation..................................................................................................................
1.10.7
Extensions ..........................................................................................................................
1.10.8
File Types ...........................................................................................................................
1.10.9
Global Ignore List .............................................................................................................
1.10.10
SQL Formatter ...................................................................................................................
1.11
Using the Help..........................................................................................................................
1.12
Supplementary Oracle Database Information .....................................................................
Tutorial: Creating Objects for a Small Database

2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
Creating a Table (Books) ............................................................................................................ 2-1

Creating a Table (Patrons) ......................................................................................................... 2-3
Creating a Table (Transactions) ................................................................................................ 2-4
Creating a Sequence.................................................................................................................... 2-6
Creating a View........................................................................................................................... 2-7
Creating a PL/SQL Procedure .................................................................................................. 2-8
Debugging a PL/SQL Procedure ............................................................................................. 2-9
Using the SQL Worksheet for Queries.................................................................................. 2-11
Script for Creating and Using the Library Tutorial Objects .............................................. 2-11
Dialog Boxes for Creating/Editing Objects

3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16
3.17
iv
1-24
1-24
1-25
1-25
1-26
1-26
1-27
1-27
1-29
1-29
1-30
1-30
1-30
1-31
1-31
1-31
1-32
Add Extension .............................................................................................................................

Apply Filter..................................................................................................................................
Check for Updates ......................................................................................................................
Choose Directory.........................................................................................................................
Create/Edit New Object ............................................................................................................
Create/Edit/Select Database Connection ...............................................................................
Select Connection ........................................................................................................................
Select Library ...............................................................................................................................
Create Library..............................................................................................................................
Export/Import Connection Descriptors ..................................................................................
Create/Edit Database Link........................................................................................................
Create/Edit Index .......................................................................................................................
Create PL/SQL Function, Procedure, or Package..................................................................
Create/Edit Sequence.................................................................................................................
Create/Edit Synonym ................................................................................................................
Create Table (quick creation) ....................................................................................................
Create/Edit Table (with advanced options) ...........................................................................
3-1
3-1
3-2
3-2
3-2
3-2
3-3
3-4
3-4
3-4
3-4
3-5
3-6
3-6
3-7
3-7
3-9
3.18
3.19
3.20
3.21
3.22
3.23
3.24
3.25
3.26
3.27
3.28
3.29
3.30
3.31
3.32
3.33
3.34
3.35
3.36
3.37
3.38
3.39
Create/Edit Trigger .................................................................................................................

Create Type (User-Defined) ...................................................................................................
Create/Edit User Defined Report..........................................................................................
Create/Edit User Defined Report Folder .............................................................................
Create/Edit View.....................................................................................................................
Configure File Type Associations..........................................................................................
Edit Value (Table Column Data) ...........................................................................................
Export Table Data ....................................................................................................................
Externally Modified Files........................................................................................................
Filter Object Types ...................................................................................................................
Find/Replace Text ...................................................................................................................
Go to Line Number ..................................................................................................................
Go to Line Number: Error.......................................................................................................
Load Preset Key Mappings.....................................................................................................
Open File ...................................................................................................................................
Recent Files ...............................................................................................................................
Run/Debug PL/SQL...............................................................................................................
Create/Edit Breakpoint...........................................................................................................
Save/Save As............................................................................................................................
Save Style Settings ...................................................................................................................
SQL History List.......................................................................................................................
SQL*Plus Location ...................................................................................................................
3-14
3-15
3-15
3-16
3-16
3-20
3-20
3-20
3-21
3-21
3-21
3-22
3-22
3-22
3-22
3-22
3-22
3-23
3-24
3-24
3-24
3-24
Database Objects: Usage Information

4.1
Overview of Managing Objects ................................................................................................ 4-1
4.2
Managing Tables ......................................................................................................................... 4-2
4.2.1
Column Data Types............................................................................................................. 4-2
4.2.2
Column Default Values....................................................................................................... 4-3
4.2.3
Ensuring Data Integrity With Constraints ....................................................................... 4-3
4.2.4
Column Constraints ............................................................................................................ 4-4
4.2.5
Table-Level Constraints ...................................................................................................... 4-4
4.2.5.1
Primary Key................................................................................................................... 4-5
4.2.5.2
Unique Key.................................................................................................................... 4-5
4.2.5.3
Check Constraint .......................................................................................................... 4-5
4.2.5.4
Foreign Key ................................................................................................................... 4-6
4.3
Managing Indexes....................................................................................................................... 4-6
4.3.1
Creating Indexes for Use with Constraints...................................................................... 4-7
4.3.2
Index Types .......................................................................................................................... 4-7
4.3.2.1
Normal ........................................................................................................................... 4-7
4.3.2.2
Ascending and Descending ........................................................................................ 4-7
4.3.2.3
Column and Function-based....................................................................................... 4-7
4.3.2.4
Single Column and Concatenated ............................................................................. 4-7
4.3.3
Guidelines for Creating Indexes........................................................................................ 4-8
4.3.3.1
Index the Correct Tables and Columns..................................................................... 4-8
4.3.3.2
Limit the Number of Indexes for Each Table ........................................................... 4-9
4.3.3.3
Choose the Order of Columns in Composite Indexes............................................. 4-9
4.3.3.4
Drop Indexes That Are No Longer Required ....................................................... 4-10
4.4
4.5
4.6
Data Types: Usage Information

5.1
5.2
5.2.1
5.2.2
5.3
5.3.1
5.3.2
5.3.3
5.3.3.1
5.3.3.2
5.4
5.4.1
5.4.1.1
5.4.1.2
5.4.1.3
5.4.1.4
5.4.1.5
5.4.2
Overview of Data Types ............................................................................................................

Storing Character Data...............................................................................................................
What are the Character Data Types? ................................................................................
Choosing Between the Character Data Types .................................................................
Storing Numeric Data ................................................................................................................
What Are the Numeric Data Types? .................................................................................
Using NUMBER Data Types..............................................................................................
Using Floating-Point Number Formats ............................................................................
BINARY_FLOAT ..........................................................................................................
BINARY_DOUBLE.......................................................................................................
Storing Datetime Data ................................................................................................................
Using DATE and TIMESTAMP Data Types ....................................................................
Using the DATE Data Type ........................................................................................
Using the TIMESTAMP Data Type............................................................................
Using the TIMESTAMP WITH TIME ZONE Data Type ........................................
Using the TIMESTAMP WITH LOCAL TIME ZONE Data Type .........................
Representing the Difference Between Datetime Values .........................................
Manipulating the DATE and TIME Formats ...................................................................
5-1
5-1
5-1
5-2
5-2
5-2
5-3
5-4
5-5
5-5
5-5
5-5
5-5
5-6
5-6
5-6
5-6
5-6
SQL: Usage Information

6.1
6.1.1
6.1.2
6.2
6.2.1
6.2.2
6.2.2.1
6.2.3
6.2.4
6.2.5
6.2.6
6.3
6.3.1
6.3.2
6.3.3
6.4
6.4.1
6.4.2
6.5
6.5.1
6.5.2
6.5.3
vi
Managing Views ...................................................................................................................... 4-10

Managing Sequences ............................................................................................................... 4-10
Managing Synonyms............................................................................................................... 4-11
Overview of SQL......................................................................................................................... 6-1

Features of SQL .................................................................................................................... 6-1
Types of SQL Statements .................................................................................................... 6-2
Retrieving Data With Queries ................................................................................................... 6-2
Displaying Data Using the SELECT Statement ............................................................... 6-2
Using Character Literals in SQL Statements.................................................................... 6-3
Quoting Character Literals.......................................................................................... 6-3
Using a Column Alias to Change Headings When Selecting Data .............................. 6-4
Restricting Data Using the WHERE Clause..................................................................... 6-4
Sorting Data Using the ORDER BY Clause...................................................................... 6-5
Displaying Data From Multiple Tables ............................................................................ 6-6
Manipulating Data With SQL Statements ............................................................................... 6-7
Adding Data With the INSERT Statement....................................................................... 6-7
Updating Data With the UPDATE Statement ................................................................. 6-8
Deleting Data With the DELETE Statement .................................................................... 6-8
Transaction Control Statements................................................................................................ 6-8
Committing Transaction Changes..................................................................................... 6-9
Rolling Back a Transaction ................................................................................................. 6-9
Using Pseudocolumns, Sequences, and SQL Functions..................................................... 6-10
Using Pseudocolumns With SQL ................................................................................... 6-10
Using Sequences ............................................................................................................... 6-11
Using Character Functions .............................................................................................. 6-11
6.5.4
6.5.5
6.5.6
6.5.7
6.6
6.6.1
6.6.2
6.6.3
6.6.4
6.6.5
6.6.6
6.6.7
Using Arithmetic Operators............................................................................................

Using Numeric Functions................................................................................................
Using Date Functions .......................................................................................................
Using Aggregate Functions.............................................................................................
Using SQL Data Definition Language Statements ..............................................................
Creating a Table With SQL..............................................................................................
Creating and Modifying an Index With SQL ...............................................................
Creating and Modifying a Constraint With SQL .........................................................
Altering a Table With SQL ..............................................................................................
Dropping a Table With SQL............................................................................................
Creating and Dropping a Sequence ...............................................................................
Creating and Dropping a Synonym...............................................................................
6-12
6-12
6-13
6-14
6-15
6-15
6-16
6-16
6-17
6-17
6-17
6-18
PL/SQL: Usage Information

7.1
Overview of PL/SQL ................................................................................................................. 7-1
7.2
Entering and Executing PL/SQL Code ................................................................................... 7-2
7.3
Utilizing the Main Features of PL/SQL .................................................................................. 7-2
7.3.1
Using PL/SQL Block Structure.......................................................................................... 7-3
7.3.2
Using Comments ................................................................................................................. 7-4
7.3.3
Declaring Variables and Constants ................................................................................... 7-4
7.3.4
Using Identifiers in PL/SQL .............................................................................................. 7-5
7.3.5
Assigning Values to a Variable With the Assignment Operator .................................. 7-6
7.3.6
Using Literals ....................................................................................................................... 7-7
7.3.7
Declaring and Assigning Variables With DEFAULT or NOT NULL .......................... 7-8
7.3.8
Assigning Values to a Variable With SELECT INTO ..................................................... 7-9
7.3.9
Inputting and Outputting Data with PL/SQL ................................................................ 7-9
7.3.10
Using %ROWTYPE and %TYPE Attributes to Declare Data Types ......................... 7-10
7.3.10.1
Using the %ROWTYPE Attribute to Declare Variables ....................................... 7-10
7.3.10.2
Using the %TYPE Attribute to Declare Variables................................................. 7-11
7.3.11
Using PL/SQL Control Structures ................................................................................. 7-11
7.3.11.1
Conditional Control With IF-THEN ....................................................................... 7-11
7.3.11.2
Conditional Control With the CASE Statement.................................................... 7-12
7.3.11.3
Iterative Control With LOOPs ................................................................................. 7-13
7.3.11.4
Sequential Control With GOTO .............................................................................. 7-15
7.3.12
Using Local PL/SQL Subprograms in PL/SQL Blocks .............................................. 7-15
7.3.13
Working With PL/SQL Data Structures ....................................................................... 7-17
7.3.13.1
Using Cursors............................................................................................................. 7-17
7.3.13.2
Using Collections....................................................................................................... 7-17
7.3.13.3
Using Records ............................................................................................................ 7-18
7.3.14
Processing Queries with PL/SQL .................................................................................. 7-19
7.3.15
Using Dynamic SQL in PL/SQL .................................................................................... 7-19
7.3.16
Using Bind Variables........................................................................................................ 7-21
7.4
Handling PL/SQL Errors ....................................................................................................... 7-21
7.4.1
Summary of Predefined PL/SQL Exceptions............................................................... 7-21
7.4.2
Using the Exception Handler.......................................................................................... 7-23
7.4.3
Declaring PL/SQL Exceptions........................................................................................ 7-23
7.4.4
Scope Rules for PL/SQL Exceptions.............................................................................. 7-23
vii
7.4.5
Subprograms and Packages: Usage Information

8.1
8.1.1
8.1.2
8.2
8.3
8.3.1
8.3.2
8.4
Continuing After an Exception is Raised ...................................................................... 7-24
Overview of Packages and Subprograms ...............................................................................

Stored Subprograms............................................................................................................
Packages ................................................................................................................................
Managing Subprograms ............................................................................................................
Managing Packages ....................................................................................................................
Calling Subprograms in Packages.....................................................................................
Accessing Variables in Packages .......................................................................................
Oracle Product-Specific Packages.............................................................................................
8-1
8-2
8-2
8-3
8-3
8-4
8-4
8-5
Triggers: Usage Information

9.1
Overview of Triggers.................................................................................................................. 9-1
9.1.1
Types of Triggers ................................................................................................................ 9-2
9.1.2
Naming Triggers ................................................................................................................. 9-2
9.1.3
When Is the Trigger Fired? ................................................................................................ 9-2
9.1.4
Controlling When a Trigger Is Fired ................................................................................ 9-2
9.1.4.1
Firing Triggers With the BEORE and AFTER Options ........................................... 9-2
9.1.4.2
Firing Triggers With the FOR EACH ROW Option ............................................... 9-3
9.1.4.3
Firing Triggers Based on Conditions (WHEN Clause) .......................................... 9-3
9.1.5
Accessing Column Values in Row Triggers .................................................................... 9-3
9.1.6
Detecting the DML Operation That Fired a Trigger....................................................... 9-4
9.1.7
Enabled and Disabled Trigger Modes .............................................................................. 9-4
9.1.8
Error Conditions and Exceptions in the Trigger Body .................................................. 9-4
9.2
Designing Triggers ..................................................................................................................... 9-5
9.2.1
Guidelines For Triggers ...................................................................................................... 9-5
9.2.2
Restrictions on Creating Triggers ..................................................................................... 9-5
9.2.3
Privileges Needed to Work with Triggers ...................................................................... 9-6
10
SQL*Plus: Usage Information

10.1
Overview of SQL*Plus ............................................................................................................
10.2
Using SQL*Plus ........................................................................................................................
10.2.1
Starting and Exiting SQL*Plus........................................................................................
10.2.2
Displaying Help With SQL*Plus ....................................................................................
10.2.3
Entering and Executing SQL Statements and Commands .........................................
10.2.4
SQL*Plus DESCRIBE Command ....................................................................................
10.2.5
SQL*Plus SET Commands...............................................................................................
10.2.6
Running Scripts From SQL*Plus ....................................................................................
10.2.7
Spooling From SQL*Plus .................................................................................................
10.2.8
Using Variables With SQL*Plus .....................................................................................
10.2.8.1
Prompting for a Variable ..........................................................................................
10.2.8.2
Defining a Variable Value for a Query...................................................................
11
Working in a Global Environment

11.1
viii
10-1
10-1
10-2
10-2
10-2
10-3
10-3
10-3
10-4
10-4
10-4
10-5
Overview of Globalization Support ...................................................................................... 11-1
11.2
Setting up the Globalization Support Environment ...........................................................
11.2.1
Setting NLS Parameters ...................................................................................................
11.2.2
Choosing a Locale with the NLS_LANG Environment Variable ..............................
11.2.3
Language and Territory Parameters ..............................................................................
11.2.3.1
NLS_LANGUAGE.....................................................................................................
11.2.3.2
NLS_TERRITORY......................................................................................................
11.2.4
Date and Time Parameters ..............................................................................................
11.2.4.1
Date Formats ..............................................................................................................
11.2.4.2
Time Formats .............................................................................................................
11.2.5
Calendar Definitions ......................................................................................................
11.2.5.1
Calendar Formats ....................................................................................................
11.2.5.2
NLS_CALENDAR ...................................................................................................
11.2.6
Numeric and List Parameters .......................................................................................
11.2.6.1
Numeric Formats.....................................................................................................
11.2.6.2
NLS_NUMERIC_CHARACTERS .........................................................................
11.2.7
Monetary Parameters .....................................................................................................
11.2.7.1
Currency Formats ....................................................................................................
11.2.7.2
NLS_CURRENCY....................................................................................................
11.2.7.3
NLS_ISO_CURRENCY ...........................................................................................
11.2.7.4
NLS_DUAL_CURRENCY......................................................................................
11.2.8
Linguistic Sorting and Searching..................................................................................
11.2.8.1
NLS_SORT................................................................................................................
11.2.8.2
NLS_COMP ..............................................................................................................
11.2.8.3
Case and Accent Insensitive Searching ................................................................
11.2.9
Length Semantics ............................................................................................................
11.2.9.1
NLS_LENGTH_SEMANTICS................................................................................
11.3
SQL and PL/SQL Programming with Unicode ................................................................
11.3.1
Overview of Unicode .....................................................................................................
11.3.2
SQL NCHAR Data Types ..............................................................................................
11.3.2.1
The NCHAR Data Type..........................................................................................
11.3.2.2
The NVARCHAR2 Data Type ...............................................................................
11.3.3
Unicode String Literals ..................................................................................................
11.4
Locale-Dependent SQL Functions with Optional NLS Parameters ...............................
11.4.1
Default Values for NLS Parameters in SQL Functions .............................................
11.4.2
Specifying NLS Parameters in SQL Functions ...........................................................
11.4.3
Unacceptable NLS Parameters in SQL Functions ......................................................
11-3
11-3
11-4
11-5
11-5
11-6
11-7
11-7
11-9
11-10
11-10
11-11
11-11
11-12
11-12
11-13
11-13
11-13
11-14
11-14
11-14
11-15
11-16
11-17
11-17
11-18
11-18
11-19
11-19
11-20
11-20
11-21
11-21
11-22
11-22
11-24
ix
1
Oracle Raptor is a graphical version of SQL*Plus that gives database developers a
convenient way to perform basic tasks. You can browse, create, edit, and delete (drop)
database objects; run SQL statements and scripts; edit and debug PL/SQL code;
manipulate and export data; and view and create reports.
You can connect to any target Oracle database schema using standard Oracle database
authentication. Once connected, you can perform operations on objects in the
database.
See the Related Topics to learn about key features of Raptor.
Related Topics
Raptor User Interface
Database Objects
Database Connections
Entering and Modifying Data
Running and Debugging Functions and Procedures
Using the SQL Worksheet
Using SQL*Plus
Using Snippets to Insert Code Fragments
Reports
Raptor Preferences
Using the Help
Supplementary Oracle Database Information
1.1 Raptor User Interface

Raptor generally uses the left side for navigation to find and select objects, and the
right side to display information about selected objects.
This help explains the default interface. However, you can
customize many aspects of the appearance and behavior of Raptor by
setting preferences (see Raptor Preferences).
Note:
Raptor Concepts and Usage 1-1
The menus at the top contain standard entries, plus entries for features specific to
Raptor (see Menus for Raptor), as shown in the following figure.
Icons under the menus perform the following actions:
New creates a new a new database object (see Create/Edit New Object).
Open opens a file (see Open File).
Save saves any changes to the currently selected object.
Save All saves any changes to all open objects.
Open SQL Worksheet opens the SQL Worksheet (see Using the SQL Worksheet).
If you do not use the drop-down arrow to specify the database connection to use,
you are asked to select a connection.
Back moves to the pane that you most recently visited. (Or use the drop-down
arrow to specify a tab view.)
Forward moves to the pane after the current one in the list of visited panes. (Or
use the drop-down arrow to specify a tab view.)
The left side of the Raptor window has tabs and panes for the Connections and
Reports navigators, icons for performing actions, and a hierarchical tree display for the
currently selected navigator, as shown in the following figure.
The Connections navigator lists database connections that have been created. To
create a new database connection, import an XML file with connection definitions, or
export or edit current connections, right-click the Connections node and select the
appropriate menu item. (For more information, see Database Connections.)
The Reports navigator lists informative reports provided by Raptor, such as a list of
tables without primary keys for each database connection, as well as any user-defined
reports. (For more information, see Reports.)
Icons under the Connections tab (above the metadata tree) perform the following
actions on the currently selected object:
Refresh queries the database for the current details about the selected object (for
example, a connection or just a table).
1-2 Raptor Online Help
Apply Filter restricts the display of objects using a filter that you specify. For
example, you can right-click the Tables node and specify a filter of EM% to see
only tables that start with EM.
The metadata tree in the Connections pane displays all the objects (categorized by
object type) accessible to the defined connections. To select an object, expand the
appropriate tree node or nodes, then click the object.
The right side of the Raptor window has tabs and panes for objects that you select or
open, as shown in the following figure, which displays information about a table
named BOOKS.
For objects other than subprograms, icons provide the following options:
Freeze View (the pin) keeps that objects tab and information in the window when
you click another object in the Connections navigator; a separate tab and display
are created for that other object. If you click the pin again, the objects display is
available for reuse.
Refresh updates the display by querying the database for the latest information.
Modify displays a dialog box for editing the object.
Actions displays a a menu with actions appropriate for the object. The actions are
the same as when you right-click an object of that type in the Connections
navigator.
To switch among objects, click the desired tabs; to close a tab, click the X in the tab. If
you make changes to an object and click the X, you are asked if you want to save the
changes.
For tables and views, this information is grouped under tabs, which are labeled near
the top. For example, for tables the tabs are Columns, Data (for seeing and modifying
the data itself), Indexes, Constraints, and so on. For most objects, the tabs include SQL,
which displays the SQL statement for creating the object.
The Messages - Log area is used for feedback information as appropriate (for example,
results of an action, or error or warning messages). If this area is not already visible,
you can display is by clicking View and then Log.
Related Topics
Using the Help
Database Objects
Raptor Preferences
1.1.1 Menus for Raptor

This topic explains menu items that are specific to Raptor.
View menu
Contains options that affect what is displayed in the Raptor interface.
Options: New View creates a new tab on the left side showing the hierarchy for only
the selected connection; Freeze View keeps the tab and information in the window
when you click another object in the Connections navigator; a separate tab and display
are created for that other object.
Connection Navigator: Moves the focus to the Connections navigator.
Log: Displays the Messages - Log pane, which can contain errors, warnings, and
informational messages.
Debugger: Displays panes related to debugging (see Running and Debugging
Functions and Procedures).
Run Manager: Displays the Run Manager pane.
Status Bar: Controls the display of the status bar at the bottom of the Raptor window.
Toolbars: Controls the display of the main toolbar (under the Raptor menus) and the
Connections navigator toolbar.
Refresh: Updates the current display for any open connections using the current
objects in the affected database or databases.
Snippet: Displays snippets (see Using Snippets to Insert Code Fragments).
Report Navigator: Displays the Report Navigator (see Reports).
Navigate menu
Contains options for navigating to panes and in the execution of subprograms.
Back: Moves to the pane that you most recently visited.
Forward: Moves to the pane after the current one in the list of visited panes.
Go to Line: Goes to the specified line number and highlights the line in the editing
window for the selected function or procedure.
Go to Last Edit: Goes to the last line that was edited in the editing window for a
function or procedure.
Go to Recent Files: Displays the Recent Files dialog box, in which you can specify a
function or procedure to go to.
Run menu
Contains options relevant when a function or procedure is selected.
Choose Active Run Configuration: [TBS...]
Run [name]: Starts execution of the specified function or procedure.
Terminate: If the function or procedure is running, terminates execution and exits.
Database Objects
Debug menu
Contains options relevant when a function or procedure is selected.
Debug [name]: Starts execution of the specified function or procedure in debug mode.
The remaining items on the Debug menu match commands on the debugging toolbar,
which is described in Running and Debugging Functions and Procedures.
Source menu
Contains options for use when editing functions and procedures.
Completion Insight, Smart Completion Insight, and Parameter Insight: Display
pop-up windows that list item as you type and from which you can select an item for
auto-completion. (See also the code insight and completion options for Code Editor
under Raptor Preferences.)
Toggle Line Comments: Inserts and removes comment indicators at the start of
selected code lines.
Indent Block: Moves the selected statements to the right.
Unindent Block: Moves the selected statements to the left.
Tools menu
Invokes Raptor tools.
SQL*Plus: Displays a command-line window for entering SQL and SQL*Plus
statements (see Using SQL*Plus). If the location of the SQL*Plus executable is not
stored in your Raptor preferences, you are asked to specify its location.
Preferences: Enables you to customize the behavior of Raptor (see Raptor Preferences).
SQL Worksheet: Displays a worksheet in which you can create, execute, and debug
SQL and PL/SQL statements using a specified connection (see Using the SQL
Worksheet).
1.2 Database Objects

You can create, edit, and delete (drop) most types of objects in an Oracle database by
using the right-click menu in the Connections navigator or by clicking the Actions
button in the detail pane display. For some objects, you can do other operations, as
appropriate for the object type.
The actions available from right-click menus and Actions
buttons depend on the Oracle Database release number for the
specified database connection. If an action mentioned in the help is
not available with a connection, it may be that the feature was not
available in that release of Oracle Database.
Note:
Related Topics
Database Objects
1.2.1 Database Links

A database link is a database object in one database that enables you to access objects
on another database. The other database need not be an Oracle Database system;
however, to access non-Oracle systems you must use Oracle Heterogeneous Services.
After you have created a database link, you can use it to refer to tables and views in
the other database. For help with specific options in creating a database link, see
Create/Edit Database Link.
You can perform the following operations on a database link by right-clicking the
database link name in the Connections navigator and selecting an item from the menu:
Test: Validates the database link.
Drop: Deletes the database link.
1.2.2 Functions
A function is a type of PL/SQL subprogram, which is a programming object that can
be stored and executed in the database server, and called from other programming
objects or applications. (Functions return a value; procedures do not return a value.)
For help with specific options in creating a PL/SQL subprogram, see Create PL/SQL
Function, Procedure, or Package.
You can perform the following operations on a function by right-clicking the function
name in the Connections navigator and selecting an item from the menu:
Open: Displays the function text so that you can view and edit it.
Run: Displays the Run/Debug PL/SQL dialog box, and then executes the function
in normal (not debug) mode.
Debug: Displays the Run/Debug PL/SQL dialog box, and then executes the
function in debug mode.
Drop: Deletes the function.
Compile: Performs a PL/SQL compilation of the function.
Compile Dependents: Performs a PL/SQL compilation of the function and any

relevant dependent subprograms (see the Dependencies tab).
1.2.3 Indexes
An index is a database object that contains an entry for each value that appears in the
indexed column(s) of the table or cluster and provides direct, fast access to rows.
Indexes are automatically created on primary key columns; however, you must create
indexes on other columns to gain the benefits of indexing. For help with specific
options in creating an index, see Create/Edit Index.
You can perform the following operations on an index by right-clicking the index
Drop: Deletes the index.

Rebuild Index: Re-creates the index or one of its partitions or subpartitions. If the
index is unusable, a successful rebuild operation makes the index usable. For a
function-based index, rebuilding also enables the index; however, if the function
on which the index is based does not exist, the rebuild operation fails.
Rename Index: Changes the name of the index.
Database Objects
Unusable Index: Prevents the index from being used by Oracle in executing
queries. An unusable index must be rebuilt, or dropped and re-created, before it
can be used again.
Coalesce Index: Merges the contents of index blocks, where possible, to free blocks
for reuse.
1.2.4 Materialized Views

A materialized view is a database object that contains the results of a query. The FROM
clause of the query can name tables, views, and other materialized views. Collectively
these objects are called master tables (a replication term) or detail tables (a data
warehousing term). This reference uses "master tables" for consistency. The databases
containing the master tables are called the master databases. For help with specific
options in creating a materialized view, see Create/Edit View, especially the View
Information or Materialized View Information tab.
1.2.5 Materialized View Logs

A materialized view log is a table associated with the master table of a materialized
view. When DML changes are made to master table data, Oracle Database stores rows
describing those changes in the materialized view log and then uses the materialized
view log to refresh materialized views based on the master table. This process is called
incremental or fast refresh. Without a materialized view log, Oracle Database must
re-execute the materialized view query to refresh the materialized view. This process is
called a complete refresh. Usually, a fast refresh takes less time than a complete refresh.
1.2.6 Packages
A package is an object that contains subprograms, which are programming objects that
can be stored and executed in the database server, and called from other programming
objects or applications. A package can contain functions or procedures, or both. For
help with specific options in creating a package, see Create PL/SQL Function,
Procedure, or Package.
You can perform the following operations on a package by right-clicking the package
New Package Body: Displays a pane in which you can enter text for the package
body.
Drop: Deletes the package.
1.2.7 Procedures
A procedure is a type of PL/SQL subprogram, which is a programming object that can
be stored and executed in the database server, and called from other programming
objects or applications. (Procedures do not return a value; functions return a value.)
For help with specific options in creating a PL/SQL subprogram, see Create PL/SQL
Function, Procedure, or Package.
You can perform the following operations on a procedure by right-clicking the
procedure name in the Connections navigator and selecting an item from the menu:
Open: Displays the procedure text so that you can view and edit it.
Run: Displays the Run/Debug PL/SQL dialog box, and then executes the
procedure in normal (not debug) mode.
Database Objects
Debug: Displays the Run/Debug PL/SQL dialog box, and then executes the
procedure in debug mode.
Drop: Deletes the procedure.
Compile: Performs a PL/SQL compilation of the procedure.
Compile Dependents: Performs a PL/SQL compilation of the procedure and any

relevant dependent subprograms (see the Dependencies tab).
1.2.8 Recycle Bin

The Recycle bin (applicable only to Oracle Database Release 10g) holds objects that
have been dropped (deleted). The objects are not actually deleted until a commit
operation is performed. Before the objects are actually deleted, you can "undelete"
them by selecting them in the Recycle bin and selecting Undrop from the right-click
menu.
You can perform the following operations on an object in the Recycle bin by
right-clicking the object name in the Recycle bin in the Connections navigator and
selecting an item from the menu:
Purge: Removes the object from the Recycle bin and deletes it.
Undrop: Moves the object from the Recycle bin back to its appropriate place in the
Connections navigator display.
1.2.9 Sequences
Sequences are used to generate unique integers. You can use sequences to
automatically generate primary key values. For conceptual and usage information
about sequences, see Managing Sequences. For help with specific options in creating
and editing a sequence, see Create/Edit Sequence.
1.2.10 Synonyms (Public and Private)

Synonyms provide alternative names for tables, views, sequences, procedures, stored
functions, packages, materialized views, Java class database objects, user-defined
object types, or other synonyms. The Connections navigator has a Synonyms node for
all synonyms (public and private) owned by the user associated with the specified
connection, and a Public Synonyms node for all public synonyms on the database
associated with the connection. For conceptual and usage information about
sequences, see Managing Synonyms. For help with specific options in creating and
editing a synonym, see Create/Edit Synonym.
1.2.11 Tables
Tables are used to hold data. Each table typically has multiple columns that describe
attributes of the database entity associated with the table, and each column has an
associated data type. You have many table creation options and table organizations
(such as partitioned tables and index organized tables), to meet a variety of enterprise
needs. To create a table, you can do either of the following:
Create the table quickly by adding columns and specifying frequently used
features. To do this, do not check Show Advanced Options in the Create Table
dialog box. For help with options for creating a table using this quick approach,
see Create Table (quick creation).
Database Objects
Create the table by adding columns and selecting from a larger set of features. To
do this, check Show Advanced Options in the Create Table dialog box. For help
with options for creating a table with advanced features, see Create/Edit Table
(with advanced options).
You can perform the following operations on a table by right-clicking the table name in
the Connections navigator and selecting an item from the menu:
Edit: Displays the Create/Edit Table (with advanced options) dialog box.
Table: Table actions include Rename, Copy (create a copy using a different name),
Drop (delete the table), Truncate (delete existing data without affecting the table
definition), Lock (sets the table lock mode: row share, exclusive, and so on), and
Comment (descriptive comment explaining the use or purpose of the table).
Export: Enables you to export some or all of the table data to a file or to the system
clipboard, in any of the following formats: XML (XML tags and data), CSV
(comma-separated values including a header row for column identifiers), SQL
Insert (INSERT statements), SQL Loader (SQL*Loader control file), and DML.
After you select a format, the Export Table Data dialog box is displayed.
Column: Column actions include Comment (descriptive comment about a
column), Add, Drop, and Normalize.
Index: Options include Create (create an index on specified columns), Create Text
(create an Oracle Text index on a column), Create Text (create a function-based
index on a column), and Drop.
Storage: Options include Shrink Table (shrink space in a table, for segments in
tablespaces with automatic segment management) and Move Table (to another
tablespace). The Shrink Table options include Compact (only defragments the
segment space and compacts the table rows for subsequent release, but does not
readjust the high water mark and does not release the space immediately) and
Cascade (performs the same operations on all dependent objects of the table,
including secondary indexes on index-organized tables).
Analyze: Options include Compute Statistics (compute exact table and column
statistics and store them in the data dictionary), Estimate statistics (estimate table
and column statistics and store them in the data dictionary), and Validate
Structure (verifies the integrity of each data block and row, and for an
index-organized table also generates the optimal prefix compression count for the
primary key index on the table). Both computed and estimated statistics are used
by the Oracle Database optimizer to choose the execution plan for SQL statements
that access analyzed objects.
Constraint: Options include Enable or Disable Single, Drop (delete a constraint),
Add Check (add a check constraint), Add Foreign Key, and Add Unique.
Privileges: If you are connected as a database user with sufficient privileges, you
can Grant or Revoke privileges on the table to other users.
Trigger: Options include Create, Enable or Disable All, Enable or Disable Single,
and Drop (delete the trigger).
You can perform the following operations on a column in a table by right-clicking the
column name in the Connections navigator and selecting an item from the menu:
Rename: Renames the column.
Drop: Deletes the column (including all data in that column) from the table.
Encrypt (for Oracle Database Release 10.2 and higher, and only if the Transparent
Data Encryption feature is enabled for the database): Displays a dialog box in
Database Objects
which you specify a supported encryption algorithm to be used for encrypting all
data in the column. Current data and subsequently inserted data are encrypted.
Decrypt (for Oracle Database Release 10.2 and higher, and only if the Transparent
Data Encryption feature is enabled for the database): Decrypts data in the column
that had been encrypted, and causes data that is subsequently inserted not to be
encrypted.
For conceptual and usage information about tables, see Managing Tables.
1.2.12 Triggers
Triggers are stored PL/SQL blocks associated with a table, a schema, or the database,
or anonymous PL/SQL blocks or calls to a procedure implemented in PL/SQL or Java.
Oracle Database automatically executes a trigger when specified conditions occur. For
conceptual and usage information about sequences, see Triggers: Usage Information.
For help with specific options in creating a trigger, see Create/Edit Trigger.
1.2.13 Types
A data type associates a fixed set of properties with the values that can be used in a
column of a table or in an argument of a procedure or function. These properties cause
Oracle Database to treat values of one data type differently from values of another
data type. Most data types are supplied by Oracle, although users can create data
types.
For conceptual and usage information about data types, see Data Types: Usage
Information. For help with specific options in creating a user-defined type, see Create
Type (User-Defined).
1.2.14 Users (Other Users)

Database users are accounts through which you can log in to the database. In the
Connections navigator, you can see the Other Users in the database associated with a
connection, but the database objects that you are allowed to see for each user are
determined by the privileges of the database user associated with the current database
connection.
1.2.15 Views
Views are virtual tables (analogous to queries in some database products) that select
data from one or more underlying tables. Oracle Database provides many view
creation options and specialized types of views (such as materialized views, described
in Materialized Views), to meet a variety of enterprise needs. For conceptual and usage
information about views, see Managing Views. For help with specific options in
creating and editing a view, see Create/Edit View.
You can perform the following operations on a view by right-clicking the view name
in the Connections navigator and selecting an item from the menu:
Edit: Displays the Create/Edit View dialog box.
Drop: Deletes the view.
Compile: Recompiles the view, to enable you to locate possible errors before run
time. You may want to recompile a view after altering one of its base tables to
ensure that the change does not affect the view or other objects that depend on it.
1.3 Database Connections

A connection is a Raptor object that specifies the necessary information for connecting
to a specific database as a specific user of that database. You must have at least one
database connection (existing, created, or imported) to use Raptor.
When you start Raptor and whenever you display the database connections dialog
box, Raptor automatically imports any connections defined in the tnsnames.ora file on
your system, if that file exists. By default, tnsnames.ora is located in the $ORACLE_
HOME/network/admin directory, but it can also be in the directory specified by the
TNS_ADMIN environment variable or registry value or (on UNIX systems) the global
configuration directory. On Windows systems, if the tnsnames.ora file exists but its
connections are not being used by Raptor, define TNS_ADMIN as a system
environment variable. For information about the tnsnames.ora file, see the "Local
Naming Parameters (tnsnames.ora)" chapter in Oracle Database Net Services Reference.
You can create additional connections (for example, to connect to the same database
but as different users, or to connect to different databases). Each database connection is
listed in the Connections navigator hierarchy.
To create a new database connection, right-click the Connections node and select New
Database Connection. Use the dialog box to specify information about the connection
(see Create/Edit/Select Database Connection).
To edit the information about an existing database connection, right-click the
connection name in the Connections navigator display and select Properties. Use the
dialog box to modify information about the connection (see Create/Edit/Select
Database Connection).
To export information about the existing database connections into an XML file that
you can later use for importing connections, right-click Connections in the
Connections navigator display and select Export Connections. Use the dialog box to
specify the connections to be exported (see Export/Import Connection Descriptors).
To import connections that had previously been exported (adding them to any
connections that may already exist in Raptor), right-click Connections in the
Connections navigator display and select Import Connections. Use the dialog box to
specify the connections to be imported (see Export/Import Connection Descriptors).
To delete a connection (that is, delete it from Raptor, not merely disconnect from the
current connection), right-click the connection name in the Connections navigator
display and select Delete. Deleting a connection does not delete the user associated
with that connection.
To connect using an existing connection, expand its node in the Connections navigator,
or right-click its name and select Connect. A SQL Worksheet window is also opened
for the connection (see Using the SQL Worksheet).
To disconnect from the current connection, right-click its name in the Connections
navigator and select Disconnect.
Sharing of Connections
By default, each connection in Raptor is shared when possible. For example, if you
open a table in the Connections navigator and two SQL Worksheets using the same
connection, all three panes use one shared connection to the database. In this example,
a commit operation in one SQL Worksheet commits across all three panes. If you want
a dedicated session, you must duplicate your connection and give it another name.
Sessions are shared by name, not connection information, so this new connection will
be kept separate from the original.
1-11
Entering and Modifying Data
Related Topics
Create/Edit/Select Database Connection
Export/Import Connection Descriptors
1.4 Entering and Modifying Data

You can use Raptor to enter data into tables and to edit and delete existing table data.
To do any of these operations, select the table in the Connections navigator, then click
the Data tab in the table detail display. The following figure shows the Data pane for a
table named BOOKS, with a filter applied to show only books whose rating is 10.
Icons and other controls under the Data tab provide the following options:
Freeze View (the pin) keeps that objects tab and information in the window when
you click another object in the Connections navigator; a separate tab and display
are created for that other object. If you click the pin again, the objects display is
available for reuse.
Insert Row adds an empty row after the selected row, for you to enter new data.
Delete Selected Row(s) marks the selected rows for deletion. The actual deletion
does not occur until you commit changes.
Commit Changes ends the current transaction and makes permanent all changes
performed in the transaction.
Rollback Changes undoes any work done in the current transaction.
Sort displays a dialog box for selecting columns to sort by. For each column, you
can specify ascending or descending order, and you can specify that null values be
displayed first.
Filter enables you to enter a SQL predicate (WHERE clause text without the
WHERE keyword) for limiting the display of data. For example, to show only
rows where the RATING column value is equal to 10, specify: rating = 10
Refresh (to the right of the icons shown in the preceding figure) queries the
database to update the data display. If a filter is specified, the refresh operation
uses the filter.
Related Topics
1.5 Running and Debugging Functions and Procedures

You can use Raptor to run and debug PL/SQL functions and procedures.
To run a function or procedure, right-click its name in the Connections navigator

and select Run, or click the Run icon above its source listing.
To debug a function or procedure, right-click its name in the Connections
navigator and select Debug, or click the Debug icon above its source listing.
In both cases, a code editing window is displayed. The following figure shows the
code editing window being used to debug a procedure named LIST_A_RATING2,
which is used for tutorial purposes in Debugging a PL/SQL Procedure.
The code editing window has the following tabs:
The Source tab displays a toolbar and the text of the function or procedure, which
you can edit. You can set and unset breakpoints for debugging by clicking to the
left of the thin vertical line beside each statement with which you want to associate
a breakpoint. (When a breakpoint is set, a red circle is displayed.)
The Privileges tab displays, for each privilege associated with the function or
procedure, the grantor and grantee, the object name, and whether the grantee can
grant the privilege to other users.
The Dependencies tab shows any objects that this function or procedure
references, and any objects that reference this function or procedure.
1-13
The Source tab toolbar has the icons shown in the following figure.
Run starts normal execution of the function or procedure.

Debug starts execution of the function or procedure in debug mode. You can use
the debugging toolbar to control the execution.
Compile performs a PL/SQL compilation of the function or procedure.
The Debugging - Log tab under the code text area contains the debugging toolbar and
informational messages. The debugging toolbar has the icons shown in the following
figure.
Find Execution Point goes to the next execution point.
Resume continues execution.
Step Over bypasses the next method and goes to the next statement after the
method.
Step Into goes to the first statement in the next method.
Step Out leaves the current method and goes to the next statement.
Step to End of Method goes to the last statement of the current method.
Pause halts execution but does not exit, thus allowing you to resume execution.
Terminate halts and exits the execution. You cannot resume execution from this
point; instead, to start running or debugging from the beginning of the function or
procedure, click the Run or Debug icon in the Source tab toolbar.
Garbage Collection removes invalid objects from the cache in favor of more
frequently accessed and more valid objects.
The Breakpoints tab under the code text area displays breakpoints, both
system-defined and user-defined.
The Smart Data tab under the code text area displays information about variables
associated with breakpoints.
The Data tab under the code text area displays information about all variables.
The Watches tab under the code text area displays information about watchpoints.
For more information about developing, compiling, and using PL/SQL functions and
procedures, see Subprograms and Packages: Usage Information.
Related Topics
Run/Debug PL/SQL (dialog box)
Debugging a PL/SQL Procedure (tutorial)
1.6 Using the SQL Worksheet

You can use the SQL Worksheet to create, edit and debug SQL, PL/SQL, and SQL*Plus
statements. You can specify any actions that can be processed by the database
connection associated with the worksheet, such as creating a table, inserting data,
creating and editing a trigger, selecting data from a table, and saving that data to a file.
When you connect to a database, a SQL Worksheet window for that connection is
automatically opened. You can also display a SQL Worksheet by selecting Tools and
then SQL Worksheet, or by clicking the Use SQL Worksheet icon under the menu bar.
In the Select Connection dialog box, select the database connection to use for your
work with the worksheet.
The SQL Worksheet has the user interface shown in the following figure:
SQL Worksheet toolbar (under the SQL Worksheet tab): Contains icons for the
following operations:
Execute Statement executes the statement at the mouse pointer in the Enter SQL
Statement box. The SQL statements can include bind variables (but not
substitution variables) of type VARCHAR2, NUMBER, or DATE; a pop-up box is
displayed for entering bind variable values.
Run Script executes all statements in the Enter SQL Statement box using the Script
Runner. The SQL statements can include bind variables (but not substitution
variables) of type VARCHAR2, NUMBER, or DATE; a pop-up box is displayed for
entering bind variable values.
Cancel: Stops the execution of any statements currently being executed.
SQL History: Displays a dialog box with information about SQL statements that
you have executed. You can save statements to a file, or append to or overwrite
statements on the worksheet (see SQL History List).
1-15
Execute Explain Plan: Generates the execution plan for the statement (internally
executing the EXPLAIN PLAN statement). To see the execution plan, click the
Explain tab. For more information, see Execution Plan.
Clear: Erases the statement or statements in the Enter SQL Statement box.
Open File: Opens a SQL script file that you specify and displays it in the Enter
SQL Statement box.
Save File: Saves the contents of the Enter SQL Statement box to a SQL script file
that you specify.
Print File: Prints the contents of the Enter SQL Statement box.
To the right of these icons is a drop-down list for changing the database
connection to use with the worksheet.
Enter SQL Statement: The statement or statements that you intend to execute. (For a
single statement, the semicolon at the end is optional in the SQL Worksheet.) SQL
keywords are automatically highlighted. To format the statement (capitalizing the
names of statements, clauses, keywords, and so on), right-click in the statement area
and select Format SQL.
Tabs display panes with the following information:
Results: Displays the results of the most recent Execute Statement operation.
Explain: Displays the output if you clicked the Explain Execution Plan icon (see
Execution Plan).
Script Output: Displays the output if you clicked Run Script (see Script Runner).
DBMS Output: [TBS... Need explanations for the following: Includes a toolbar with
the following icons: Enable DBMS Output, Clear, Save, Print. Also: Buffer Size,
and a slider with the text Poll.]
OWA Output: [TBS... Need explanations for the following: Includes a toolbar with the
following icons: Enable OWA Output, Clear, Save, Print.]
Related Topics
SQL*Plus Statements Supported and Not Supported in SQL Worksheet
Script Runner
Execution Plan
Using the SQL Worksheet for Queries (tutorial)
1.6.1 SQL*Plus Statements Supported and Not Supported in SQL Worksheet

The SQL Worksheet supports some SQL*Plus statements. SQL*Plus statements must
be interpreted by the SQL Worksheet before being passed to the database; any
SQL*Plus that are not supported by the SQL Worksheet are ignored and not passed to
the database.
The following SQL*Plus statements are supported by the SQL Worksheet:
@
@@
acc[ept]
conn[ect]
def[ine]
desc[ribe]
doc[ument]
exec[ute]
exit (Stops execution and reinstates the specified connection)
pro[mpt]
quit (Stops execution and reinstates the specified connection)
rem[ark]
roll[back]
sta[rt]
undef[ine]
whenever
The following SQL*Plus statements are not supported by the SQL Worksheet:
a[ppend]
archive
attr[ibute]
bre[ak]
bti[tle]
c[hange]
cl[ear]
col[ulmn]
comp[ute]
copy
del
disc[onnect]
ed[it]
get
help
ho[st]
i[nput]
l[ist]
newpage
oradebug
passw[ord]
pau[se]
print
r[un]
recover
repf[ooter]
reph[eader]
sav[e]
sho[w]
shu[tdown]
spo[ol]
startup
store
timi[ng]
tti[tle]
var[iable]
Related Topics
1.6.2 Script Runner

The script runner emulates a limited set of SQL*Plus features. If you do not have
SQL*Plus on your system, you can often enter SQL and SQL*Plus statements and
1-17
Using SQL*Plus
execute them by clicking the drop-down next to the Execute Statement icon and
selecting Run Script. The Script Output pane displays the output.
The SQL*Plus features available in the script runner include @, @@, CONNECT, EXIT,
QUIT, UNDEFINE, WHENEVER, and substitution variables. For example, to run a
script named c:\myscripts\mytest.sql, type @c:\myscripts\mytest in the Enter SQL
Statement box, and click the drop-down next to the Execute Statement icon and select
Run Script.
The following considerations apply to using the Raptor script runner:
You cannot use bind variables. (The Execute SQL Statement feature does let you
use bind variables of type VARCHAR2, NUMBER, and DATE.)
For substitution variables, the syntax &&variable assigns a permanent variable
value, and the syntax &variable assigns a temporary (not stored) variable value.
For EXIT and QUIT, commit is the default behavior, but you can specify rollback.
In either case, the context is reset: for example, WHENEVER command
information and substitution variable values are cleared.
DESCRIBE works for tables, but not for all object types with which it is supported
in SQL*Plus.
For SQL*Plus commands that are not supported, a warning message is displayed.
SQL*Plus comments are ignored.
If you have SQL*Plus available on your system, you may want to use it instead of the
script runner. To start SQL*Plus from Raptor, click Tools and then SQL*Plus. For
information about SQL*Plus, see Using SQL*Plus.
Related Topics
1.6.3 Execution Plan

The Execute Explain Plan icon generates the execution plan, which you can see by
clicking the Explain tab. The execution plan is the sequence of operations that will be
performed to execute the statement. An execution plan shows a row source tree with
the hierarchy of operations that make up the statement. For each operation, it shows
the ordering of the tables referenced by the statement, access method for each table
mentioned in the statement, join method for tables affected by join operations in the
statement, and data operations such as filter, sort, or aggregation.
In addition to the row source tree, the plan table displays information about
optimization (such as the cost and cardinality of each operation), partitioning (such as
the set of accessed partitions), and parallel execution (such as the distribution method
of join inputs). For more information, see the chapter about using EXPLAIN PLAN in
Oracle Database Performance Tuning Guide.
Related Topics
1.7 Using SQL*Plus

You can use the SQL*Plus command-line interface to enter SQL and PL/SQL
statements accessing the database associated with a specified connection. To display
the SQL*Plus command window, from the Tools menu, select SQL*Plus.
To use this feature, the system on which you are using Raptor must have an Oracle
Home directory or folder, with a SQL*Plus executable under that location. If the
location of the SQL*Plus executable is not already stored in your Raptor preferences,
you are asked to specify its location (see SQL*Plus Location).
If you do not have a SQL*Plus executable on your system, you can execute come
SQL*Plus statements using the SQL Worksheet (see SQL*Plus Statements Supported
and Not Supported in SQL Worksheet), and you can also use the Raptor script runner
feature to emulate a limited set of SQL*Plus features (see Script Runner).
For more information about using SQL*Plus, see SQL*Plus: Usage Information.
Related Topics
SQL*Plus Location (dialog box)
SQL*Plus Statements Supported and Not Supported in SQL Worksheet
Script Runner
1.8 Using Snippets to Insert Code Fragments

Snippets are code fragments, such as SQL functions, Optimizer hints, and
miscellaneous PL/SQL programming techniques. Some snippets are just syntax, and
others are examples. You can insert and edit snippets when you are using the SQL
Worksheet or creating or editing a PL/SQL function or procedure.
To display snippets, from the View menu, select Snippets. In the snippets window (on
the right side), use the drop-down to select a group (such as Aggregate Functions or
Character Functions). In most cases, the fragments in each group do not represent all
available objects in that logical grouping, or all formats and options of each fragment
shown. For complete and detailed information, see the Oracle Database
documentation.
A Snippets button is placed in the right window margin, so that you can display the
snippets window if it becomes hidden.
To insert a snippet into your code in a SQL Worksheet or in a PL/SQL function or
procedure, drag the snippet from the snippets window and drop it into the desired
place in your code; then edit the syntax so that the SQL function is valid in the current
context. To see a brief description of a SQL function in a tool tip, hold the pointer over
the function name.
For example, you could type SELECT and then drag CONCAT(char1, char2) from the
Character Functions group. Then, edit the CONCAT function syntax and type the rest
of the statement, such as in the following:
SELECT CONCAT(title, ' is a book in the library.') FROM books;
Related Topics
1-19
Reports
1.9 Reports
Raptor provides many reports about the database and its objects. You can also create
your own user-defined reports. To display reports, click the Reports tab on the left side
of the window (see Raptor User Interface). If this tab is not visible, select View and
then Reports.
Individual reports are displayed in tabbed panes on the right side of the window; and
for each report, you can select (in a drop-down control) the database connection for
which to display the report. For reports about objects, the objects shown are only those
visible to the database user associated with the selected database connection, and the
rows are usually ordered by Owner.
To see the SQL statement used to retrieve the information for a report, click the SQL
icon above the report and to the right of the database connection. Clicking this icon
displays the statement in the SQL Worksheet (see Using the SQL Worksheet).
The time required to display specific reports will vary, and may be affected by the
number and complexity of objects involved, and by the speed of the network
connection to the database.
Reports are grouped in the following categories:
About Your Database reports list release information about the database associated
with the connection.
Database Administration reports list usage information about system resources.
Table reports list information about tables owned by the user associated with the
specified connection. These reports can help you to better understand the metadata
and data. The table reports include Quality Assurance reports that indicate possible
logical design flaws and sources of run-time performance problems.
PL/SQL reports list information about your PL/SQL objects and allow you to search
the source of those objects.
Security reports list privilege-related information about the database.
XML reports list information about XML objects.
Jobs reports list information about jobs running on the database.
Streams reports list information about stream rules.
All Objects reports list information about all objects accessible to the user associated
with the specified database connection, not just objects owned by the user.
Data Dictionary reports list information about the data dictionary views that are
accessible in the database. Examples of data dictionary views are ALL_OBJECTS and
USER_TABLES.
User Defined reports are any customized reports that you have created.
Bind Variables for Reports
For some reports, you are prompted for bind variables before the report is generated.
These bind variables let you further restrict the output. The default value for all bind
variables is null, which implies no further restrictions. To specify a bind variable,
uncheck Null and type an entry in the Value field. Any bind variable values that you
enter are case insensitive, all matches are returned where the value string appears
anywhere in the name of the relevant object type.
Reports
Related Topics
1.9.1 About Your Database reports

The About Your Database reports list release information about the database
associated with the selected connection. The reports include Version Banner (database
settings) and National Language Support Parameters (NLS_xxx parameter values for
globalization support).
Related Topics
Reports
1.9.2 Database Administration reports

Database Administration reports list usage information about system resources. This
information can help you to manage storage, user accounts, and sessions efficiently.
Database Parameters: Provide information about all database parameters or only
those parameters that are not set to their default values.
Storage: Provide usage and allocation information for tablespaces and data files.
Sessions: Provide information about sessions, selected and ordered by various criteria.
Top SQL: Provide information about SQL statements, selected and ordered by various
criteria. This information might help you to identify SQL statements that are being
executed more often than expected or that are taking more time than expected.
Users: Provide information about database users, selected and ordered by various
criteria. For example, you can find out which users were created most recently, which
user accounts have expired, and which users use object types and how many objects
each owns.
Related Topics
Reports
1.9.3 Table reports

Table reports list information about tables owned by the user associated with the
specified connection. This information is not specifically designed to identify problem
areas; however, depending on your resources and requirements, some of the
information might indicate things that you should monitor or address.
For table reports, the owner is the user associated with the database connection.
Columns: For each table, lists each column, its data type, and whether it can contain a
null value.
Datatype Occurrences: For each table owner, lists each data type and how many times
it is used.
Comments for tables and columns: For each table and for each column in each table,
lists the descriptive comments (if any) associated with it. Also includes a report of
1-21
Reports
tables without comments. If database developers use the COMMENT statement when
creating or modifying tables, this report can provide useful information about the
purposes of tables and columns
Constraints: For each table, lists each associated constraint, including its type (unique
constraint, check constraint, primary key, foreign key) and status (enabled or
disabled).
Enabled Constraints and Disabled Constraints: For each constraint with a status of
enabled or disabled, lists the table name, constraint name, constraint type (unique
constraint, check constraint, primary key, foreign key), and status. A disabled
constraint is not enforced when rows are added or modified; to have a disabled
constraint enforced, you must edit the table and set the status of the constraint to
Enabled (see the appropriate tabs for Create/Edit Table (with advanced options)).
Primary Key Constraints: For primary key constraint, lists information that includes
the owner, the table name, the constraint name, the constraint status (enabled or
disabled), and the column name.
Unique Constraints: For each unique constraint, lists information that includes the
owner, the table name, the constraint name, the constraint status (enabled or disabled),
and the column name.
Foreign Key Constraints: For each foreign key constraint, lists information that
includes the owner, the table name, the constraint name, the column that the constraint
is against, the table that the constraint references, and the constraint in the table that is
referenced.
Check Constraints: For each check constraint, lists information that includes the
owner, the table name, the constraint name, the constraint status (enabled or disabled),
and the constraint specification.
Statistics: For each table, lists statistical information, including when it was last
analyzed, the total number of rows, the average row length, and the table type. In
addition, specialized reports order the results by most rows and largest average row
length.
Storage - Tables by Tablespace: For each tablespace, lists the number of tables and the
total number of megabytes currently allocated for the tables.
Storage - Tablespaces: For each table, lists the tablespace for the table and the number
of megabytes currently allocated for the table.
Organization: Specialized reports list information about partitioned tables, clustered
tables, and index organized tables.
Quality Assurance reports
Quality assurance reports identify conditions that are not technically errors, but that
usually indicate flaws in the database design. These flaws can result in various
problems, such as logic errors and the need for additional application coding to work
around the errors, as well as poor performance with queries at run time.
Tables without Primary Keys: Lists tables that do not have a primary key defined. A
primary key is a column (or set of columns) that uniquely identifies each row in the
table. Although tables are not required to have a primary key, it is strongly
recommended that you create or designate a primary key for each table. Primary key
columns are indexed, which enhances performance with queries, and they are
required to be unique and not null, providing some "automatic" validation of input
data. Primary keys can also be used with foreign keys to provide referential integrity.
Reports
Tables without Indexes: Lists tables that do not have any indexes. If a column in a
table has an index defined on it, queries that use the column are usually much faster
and more efficient than if there is no index on the column, especially if there are many
rows in the table and many different data values in the column.
Tables with Unindexed Foreign Keys: Lists any foreign keys that do not have an
associated index. A foreign key is a column (or set of columns) that references a
primary key: that is, each value in the foreign key must match a value in its associated
primary key. Foreign key columns are often joined in queries, and an index usually
improves performance significantly for queries that use a column. If an unindexed
foreign key is used in queries, you may be able to improve run-time performance by
creating an index on that foreign key.
Related Topics
Reports
1.9.4 PL/SQL reports

PL/SQL reports list information about PL/SQL packages, function, and procedures,
and about types defined in them.
Program Unit Arguments: For each argument (parameter) in a program unit, lists the
program unit name, the argument position (1, 2, 3, and so on), the argument name,
and whether the argument is input-only (In), output-only (Out), or both input and
output (In/Out).
Unit Line Counts: For each PL/SQL object, lists the number of source code lines. This
information can help you to identify complex objects (for example, to identify code
that may need to be simplified or divided into several objects).
Search Source Code: For each PL/SQL object, lists the source code for each line, and
allows the source to be searched for occurrences of the specified variable.
Related Topics
Reports
1.9.5 Security reports

Security reports list information about users that have been granted privileges, and in
some cases about the users that granted the privileges. This information can help you
(or the database administrator if you are not a DBA) to understand possible security
issues and vulnerabilities, and to decide on the appropriate action to take (for
example, revoking certain privileges from users that do not need those privileges).
Object Grants: For each privilege granted on a specific table, lists the user that granted
the privilege, the user to which the privilege was granted, the table, the privilege, and
whether the user to which the privilege was granted can grant that privilege to other
users.
Column Privileges: For each privilege granted on a specific column in a specific table,
lists the user that granted the privilege, the user to which the privilege was granted,
the table, the privilege, and whether the user to which the privilege was granted can
grant that privilege to other users.
Role Privileges: For each granted role, lists the user to which the role was granted, the
role, whether the role was granted with the ADMIN option, and whether the role is
designated as a default role for the user.
1-23
Reports
System Privileges: For each privilege granted to the user associated with the database
connection, lists the privilege and whether it was granted with the ADMIN option.
Auditing: Lists information about audit policies.
Encryption: Lists information about encrypted columns.
Policies: Lists information about policies.
Related Topics
Reports
1.9.6 XML reports

XML reports list information about XML objects.
XML Schemas: For each user that owns any XML objects, lists information about each
object, including the schema URL of the XSD file containing the schema definition.
Related Topics
Reports
1.9.7 Jobs reports

Jobs reports list information about jobs running on the database.
Your Jobs: Lists information about each job for which the user associated with the
database connection is the log user, privilege user, or schema user. The information
includes the start time of its last run, current run, and next scheduled run.
All Jobs: Lists information about all jobs running on the database. The information
includes the start time of its last run, current run, and next scheduled run.
Related Topics
Reports
1.9.8 Streams reports

Streams reports list information about stream rules.
Your Stream Rules: Lists information about each stream rule for which the user
associated with the database connection is the rule owner or rule set owner. The
information includes stream type and name, rule set owner and name, rule owner and
name, rule set type, streams rule type, and subsetting operation.
All Stream Rules: Lists information about all stream rules. The information includes
stream type and name, rule set owner and name, rule owner and name, rule set type,
streams rule type, and subsetting operation.
Related Topics
Reports
1.9.9 All Objects reports

All Objects reports list information about objects visible to the user associated with the
database connection.
All Objects: For each object, lists the owner, name, type (table, view, index, and so on),
status (valid or invalid), the date it was created, and the date when the last data
Reports
definition language (DDL) operation was performed on it. The Last DDL date can help
you to find if any changes to the object definitions have been made on or after a
specific time.
Invalid Objects: Lists all objects that have a status of invalid.
Object Count by Type: For each type of object associated with a specific owner, lists
the number of objects. This report might help you to identify users that have created
an especially large number of objects, particularly objects of a specific type.
Collection Types: Lists information about for each collection type. The information
includes the type owner, element type name and owner, and type-dependent specific
information.
Dependencies: For each object with references to it, lists information about references
to (uses of) that object.
Related Topics
Reports
1.9.10 Data Dictionary reports

Data Dictionary reports list information about the data dictionary views that are
accessible in the database. Examples of data dictionary views are ALL_OBJECTS and
USER_TABLES.
Dictionary Views: Lists each Oracle data dictionary view and (in most cases) a
comment describing its contents or purpose.
Dictionary View Columns: For each Oracle data dictionary view, lists information
about the columns in the view.
Related Topics
Reports
1.9.11 User Defined reports

User Defined reports are any reports that are created by Raptor users. To create a
user-defined report, right-click the User Defined node under Reports and select Add
Report. A dialog box is displayed in which you specify the report name and the SQL
query to retrieve information for the report (see Create/Edit User Defined Report).
You can organize user-defined reports in folders, and you can create a hierarchy of
folders and subfolders. To create a folder for user-defined reports, right-click the User
Defined node or any folder name under that node and select Add Folder (see
Create/Edit User Defined Report Folder).
Related Topics
Reports
Create/Edit User Defined Report
Create/Edit User Defined Report Folder
1-25
Raptor Preferences
1.10 Raptor Preferences

You can customize many aspects of the Raptor interface and environment by
modifying Raptor preferences according to your preferences and needs. To modify
Raptor preferences, select Tools, then Preferences.
Most preferences are self-explanatory, and this topic explains only those whose
meaning and implications are not obvious. Some preferences involve slight or
performance or system resource trade-offs (for example, enabling a feature that adds
execution time), and other preferences involve only personal aesthetic taste. The
preferences are grouped in the following categories.
1.10.1 Environment
The Environment pane contains options that affect the startup and overall behavior
and appearance of Raptor. You can specify that certain operations be performed
automatically at specified times, with the trade-off usually being the extra time for the
operation as opposed to the possibility of problems if the operation is not performed
automatically (for example, if you forget to perform it when you should).
The undo level (number of previous operations that can be undone) and navigation
level (number of open files) values involve slight increases or decreases system
resource usage for higher or lower values.
Automatically Reload Externally Modified Files: If this option is checked, any files
open in Raptor that have been modified by an external application are updated when
you switch back to Raptor, overwriting any changes that you might have made. If this
option is not checked, changes that you make in Raptor overwrite any changes that
might have been made by external applications.
Silently Reload When File Is Unmodified: If this option is checked, you are not asked
if you want to reload files that have been modified externally but not in Raptor. If this
option is not checked, you are asked if you want to reload each file that has been
modified externally, regardless of whether it has been modified in Raptor,
Environment: Dockable Windows
The Dockable Windows pane configures the behavior of dockable windows and the
shapes of the four docking areas of Raptor: top, bottom, left, and right.
Dockable Windows Always on Top: If this option is checked, dockable windows
always remain visible in front of other windows.
Windows Layout: Click the corner arrows to lengthen or shorten the shape of each
docking area.
Environment: Local History
The Local History pane controls whether information about editing operations on files
opened within Raptor is kept. If local history is enabled, you can specify how long
information is retained and the maximum number of revisions for each file.
Environment: Log
The Log pane configures the colors of certain types of log messages and the saving of
log messages to log files.
Save Logs to File: If this option is checked, all output to the Messages - Log window is
saved to log files, where the file name reflects the operation and a timestamp. You are
also asked to specify a Log Directory; and if the specified directory does not already
Raptor Preferences
exist, it is created. Note that is you save log information to files, the number of these
files can become large.
Maximum Log Lines: The maximum number of lines to store in each log file.
Related Topics
Raptor Preferences
1.10.2 Accelerators
The Accelerators pane enables you to customize the accelerator key mappings for
Raptor.
Category: Select All or a specific category, to control which actions are displayed.
Actions: The actions for the selected category. When you select an action, any existing
accelerator key mappings are displayed.
Accelerators: Any existing key mappings for the selected action. To remove an existing
key mapping, select it and click Remove.
New Accelerator: The new accelerator key to be associated with the action. Press and
hold the desired modifier key, then press the other key. For example, to associate
Ctrl+J with an action, press and hold the Ctrl key, then press the j key. If any actions
are currently associated with that accelerator key, they are listed in the Current
Assignment field.
Load Preset: Enables you to load a set of predefined key mappings for certain systems
and external editing applications. If you load any preset key mappings that conflict
with changes that you have made, your changes are overwritten.
Related Topics
Raptor Preferences
1.10.3 Code Editor

The Code Editor pane contains general options that affect the appearance and
behavior of Raptor when you edit functions, procedures, and packages.
Code Editor: Bookmarks
The Bookmarks pane contains options that determine the persistence and search
behavior for bookmarks that you create when using the code editor.
Code Editor: Caret Behavior
The Caret Behavior pane contains options that determine the shape, color, and
blinking characteristics of the caret (cursor) in the code editor
Code Editor: Code Insight
The Code Insight pane contains options for the logical completion of keywords and
names while you are coding.
Code Editor: Code Insight: Completion
The Code Insight: Completion pane contains options for refining the behavior when
matching items are found.
1-27
Raptor Preferences
Code Editor: Display

The Display pane contains general options for the appearance and behavior of the
code editor.
Text Anti-Aliasing allows smooth-edged characters where possible.
Code Folding Margin allows program blocks in procedures and functions to be
expanded and collapsed in the display.
Visible Right Margin renders a right margin that you can set to control the length of
lines of code.
Automatic Brace Matching controls the highlighting of opening parentheses and
brackets and of blocks when a closing parenthesis or bracket is typed.
Code Editor: Find Options
The Find Options pane determines which options are used by default at Raptor
startup for find or find and replace operations. You can choose whether to use the
options in effect from the last Raptor session or to use specified options.
Code Editor: Fonts
The Fonts pane specifies text font options for the code editor.
Display Only Fixed-Width Fonts: If this option is checked, the display of available
font names is restricted to fonts where all characters have the same width.
(Fixed-width fonts are contrasted with proportional-width fonts.)
Code Editor: Line Gutter
The Line Gutter pane specifies options for the line gutter (left margin of the code
editor).
Show Line Numbers: If this option is checked, lines are numbered.
Enable Line Selection by Click-Dragging: If this option is checked, you can select
consecutive lines in the editor by clicking in the gutter and dragging the cursor
without releasing the mouse button.
Code Editor: Printing
The Printing pane specifies options for printing the contents of the code editor. The
Preview pane sample display changes as you select and deselect options.
Code Editor: Printing HTML
The Printing HTML pane specifies options for printing HTML files from the code
editor.
Code Editor: Syntax Colors
The Syntax Colors pane specifies colors for different kinds of syntax elements.
Code Editor: Undo Behavior
The Undo Behavior pane specifies options for the behavior of undo operations
(Ctrl+Z, or Edit, then Undo). Only consecutive edits of the same type are considered; for
example, inserting characters and deleting characters are two different types of
operation.
Allow Navigation-Only Changes to be Undoable: If this option is checked,
navigation actions with the keyboard or mouse can be undone. If this option is not
Raptor Preferences
checked, navigation actions cannot be undone, and only actual changes to the text can
be undone.
Related Topics
Raptor Preferences
1.10.4 Database Connections

The Database Connections pane sets connection properties.
Validate date and time default values: If this option is checked, date and time
validation is used when you open tables.
Generate PL/SQL Debug Information: If this option is checked, debugging
information is enabled when you compile PL/SQL code.
SQL*Plus Executable: The Windows path or Linux xterm command for the SQL*Plus
executable. If there is no $ORACLE_HOME on your system, there is no SQL*Plus
executable, and you cannot use SQL*Plus with Raptor; however, you can still use
many SQL*Plus commands in the SQL Worksheet (see Using the SQL Worksheet, and
especially SQL*Plus Statements Supported and Not Supported in SQL Worksheet).
Related Topics
Using SQL*Plus
Raptor Preferences
1.10.5 Debugger
The Debugger pane contains general options for the Raptor debugger. Other panes
contain additional specific kinds of debugger options.
Debugger: Breakpoints
The Breakpoints tab sets the columns to appear in the Breakpoints pane and the scope
of each breakpoint.
Debugger: Breakpoints: Default Actions
The Breakpoints: Default Actions tab sets defaults for actions to occur at breakpoints.
These actions are the same as on the Actions tab in the Create/Edit Breakpoint dialog
box.
Debugger: Data
The Data tab pane enables you to control the columns to appear in the debugger Data
pane and aspects of how the data is displayed.
Debugger: Inspector
The Inspector tab enables you to control the columns to appear in the debugger
Inspector pane and aspects of how the data is displayed.
Debugger: Smart Data
The Smart Data tab enables you to control the columns to appear in the debugger
Smart Data pane and aspects of how the data is displayed.
1-29
Raptor Preferences
Debugger: Stack
The Stack tab enables you to control the columns to appear in the debugger Stack pane
and other options.
Debugger: Watches
The Watches tab enables you to control the columns to appear in the debugger
Watches pane and aspects of how the data is displayed.
Related Topics
Raptor Preferences
1.10.6 Documentation
The Documentation pane provides options for the display of Raptor online help.
Display in Window: If this option is checked, help is displayed in a separate window.
If this option is not checked, help is displayed in a pane in the Raptor User Interface.
Show Tabs: Controls which tabs appear in the Help Center pane (Table of Contents,
Index, Full Text Search).
Related Topics
Using the Help
Raptor Preferences
1.10.7 Extensions
The Extensions pane determines which extensions Raptor uses what it starts. If you
change any settings, you must exit Raptor and restart it for the new setting to take
effect.
Extensions to Use: Controls the specific extensions to use at startup.
Check for Updates: Checks for any updates to the selected extensions.
Automatically Check for Updates: If this option is checked, Raptor automatically
checks for any updates to the selected extensions at startup.
Related Topics
Raptor Preferences
1.10.8 File Types

The File Types pane determines which file types and extensions will be opened by
default by Raptor. The display shows each file extension, the associated file type, and a
check mark if files with that extension are to be opened by Raptor be default, such as
when a user double-clicks the file name.
Details area at bottom: You can modify the file type, content type (text or binary), and
whether to open files of this extension automatically by Raptor.
To have files of a specific extension be opened by default by Raptor, click the file
extension in the list, then check Open with Raptor in the Details area. This overrides
any previous application association that may have been in effect for that file
extension.
Using the Help
To add a file extension, click Add and specify the file extension (including the period).
After adding the extension, you can modify its associated information by selecting it
and using the Details area.
Related Topics
Configure File Type Associations (dialog box)
Raptor Preferences
1.10.9 Global Ignore List

The Global Ignore List pane identifies files and file types that Raptor will not use in
any processing.
New Filter: Enter a file name (for example, abc.txt) or a wildcard (*) and file type (for
example, *.txt) to identify a specific file or all files of a specified type to be ignored;
then click Add to add it to the list.
To remove an item from the list, select it and click Remove.
To restore the default global ignore list, click Restore Defaults.
Related Topics
Raptor Preferences
1.10.10 SQL Formatter

The SQL Formatter pane controls how statements in the SQL Worksheet are formatted
when you click Format SQL. The options include whether to insert space characters or
tab characters when you press the Tab key (and how many characters), uppercase or
lowercase for keywords and identifiers, whether to preserve or eliminate empty lines,
and whether comparable items should be placed or the same line (if there is room) or
on separate lines.
Related Topics
Raptor Preferences
1.11 Using the Help

Raptor provides a Help menu and context-sensitive help (click the Help button or
press the F1 key in certain contexts).
By default, help from the Help menu is displayed on the right side of the window,
with the Help Center area on the far right and containing tabs at the bottom. You can
use the Contents, Index, and Search (full-text) tabs or their corresponding Help menu
items. Context-sensitive help is displayed in a separate help window. (To change the
default help behavior, set Raptor Documentation preferences.)
For help displayed in the Raptor window, you can close individual Help Content
windows by clicking the X next to their tab names (just as with tabs for tables and
other database objects).
To print a group of related topics, right-click the associated book icon in the Help
contents hierarchy and select Print Topic Subtree. For example, to print all
introductory topics, right-click the book icon for Raptor Introduction and select Print
Topic Subtree.
1-31
To print a single topic, display it in the Help Content area and click the Print icon, or
right-click its page icon in the Help contents hierarchy and select Print Topic Subtree.
The best way to become familiar with the help, and with Raptor itself, is simply to
experiment with the Help menu options and the Help button in some dialog boxes.
Related Topics
1.12 Supplementary Oracle Database Information

In addition to information about Raptor, this online help includes conceptual and
usage information adapted from some Oracle Database manuals. This information
appears in and under the following major topics, which are top-level books in the help
Table of Contents:
However, this supplementary information sometimes covers only basic information

and features. For conceptual, usage, and reference information about the full set of
Oracle Database features and options, see the Oracle Documentation Library for your
installation of Oracle Database.
2
Tutorial: Creating Objects for a Small
Database
In this tutorial, you will use Raptor to create objects for a simplified library database,
which will include tables for books, patrons (people who have library cards), and
transactions (checking a book out, returning a book, and so on).
Tip: To print this tutorial, right-click its book icon in the Help
Contents display and select Print Topic Subtree.
The tables are deliberately oversimplified for this tutorial. They would not be adequate
for any actual public or organizational library. For example, this library contains only
books (not magazines, journals, or other document formats), and it can contain no
more than one copy of any book.
You will perform the following major steps:
Creating a Table (Books)
Creating a Table (Patrons)
Creating a Table (Transactions)
Creating a Sequence
Creating a View
Creating a PL/SQL Procedure
Debugging a PL/SQL Procedure (optional)
Using the SQL Worksheet for Queries (optional)
Related Topics
Script for Creating and Using the Library Tutorial Objects
Database Objects
2.1 Creating a Table (Books)

The Books table contains a row for each book in the library. It includes columns of
character and number types, a primary key, a unique constraint, and a check
constraint. You will use the Create Table dialog box to create the table declaratively;
Tutorial: Creating Objects for a Small Database 2-1
Creating a Table (Books)
the table that you create will be essentially the same as if you had entered the
following statement using the SQL Worksheet:
CREATE TABLE books (
book_id VARCHAR2(20) PRIMARY KEY,
title VARCHAR2(50)
CONSTRAINT title_not_null NOT NULL,
author_last_name VARCHAR2(30)
CONSTRAINT last_name_not_null NOT NULL,
author_first_name VARCHAR2(30),
rating NUMBER,
CONSTRAINT rating_1_to_10 CHECK (rating IS NULL OR
(rating >= 1 and rating <= 10)),
CONSTRAINT author_title_unique UNIQUE (author_last_name, title));
To create the Books table, connect to the database as the user in the schema you want
to use for this tutorial. Right-click the Tables node in the schema hierarchy on the left
side, select Create Table, and enter the following information. (If a tab or field is not
mentioned, do not enter anything for it.)
For detailed information about the table dialog box and its tabs, see Create Table
(quick creation) and Create/Edit Table (with advanced options).
Schema: Specify your current schema as the schema in which to create the table.
Name: Books
Create the table columns using the following information. After creating each column
except the last one (rating), click Add Column to add the next column. (If you
accidentally click OK instead of Add Column, right-click the BOOKS table in the
Connections navigator display, select Edit, and continue to add columns.)
Column Name
Type
Size
Other Information and Notes
book_id
VARCHAR2 20
Primary Key (Automatically checks Not Null;

an index is also created on the primary key
column. This is the Dewey code or other book
identifier.)
title
VARCHAR2 50
Not Null
author_last_name
VARCHAR2 30
Not Null
author_first_name
VARCHAR2 30
rating
NUMBER
(Librarians personal rating of the book, from 1

(poor) to 10 (great))
After you have entered the last column (rating), check Show Advanced Options (next
to Schema). This displays additional tabs for more table options. For this table, you
will use the Unique Constraints and Check Constraints tabs.
Unique Constraints tab
Click Add to add a unique constraint for the table, namely, that the combination of
author_last_name and title must be unique within the table. (This is deliberately
oversimplified, since most major libraries will have allow more than one copy of a
book in their holdings. Also, the combination of last name and title is not always
"foolproof" check for uniqueness, but it is sufficient for this simple scenario.)
Name: author_title_unique
Creating a Table (Patrons)
In Available Columns, double-click TITLE and then AUTHOR_LAST_NAME to move

them to Selected Columns.
Check Constraints tab
Click Add to add a check constraint for the table, namely, that the rating column value
is optional (it can be null), but if a value is specified, it must be a number from 1
through 10. You must enter the condition using SQL syntax that is valid in a CHECK
clause (but do not include the CHECK keyword or enclosing parentheses for the entire
CHECK clause text).
Name: rating_1_to_10
Condition: rating is null or (rating >= 1 and rating <= 10)
Click OK to finish creating the table.
Go to Creating a Table (Patrons) to create the next table.
Related Topics
2.2 Creating a Table (Patrons)

The Patrons table contains a row for each patron who can check books out of the
library (that is, each person who has a library card). It includes an object type
(MDSYS.SDO_GEOMETRY) column. You will use the Create Table dialog box to create
the table declaratively; the table that you create will be essentially the same as if you
had entered the following statement using the SQL Worksheet:
CREATE TABLE Patrons (
patron_id NUMBER PRIMARY KEY,
last_name VARCHAR2(30)
CONSTRAINT patron_last_not_null NOT NULL,
first_name VARCHAR2(30),
street_address VARCHAR2(50),
city_state_zip VARCHAR2(50),
location MDSYS.SDO_GEOMETRY);
The use of single city_state_zip column for all that information is not good database
design; it is done here merely to simplify your work in the tutorial.
The location column (Oracle Spatial geometry representing the patrons geocoded
address) is merely to show the use of a complex (object) type.
To create the Patrons table, if you are not already connected, connect to the database as
the user for the schema you are using for this tutorial. Right-click the Tables node in
the schema hierarchy on the left side, select Create Table, and enter the following
information. (If a tab or field is not mentioned, do not enter anything for it.)
Name: Patrons
Create most of the table columns using the following information. After creating each
column except the city_state_zip column, click Add Column to add the next column.
(If you accidentally click OK instead of Add Column, right-click the PATRONS table in
the Connections navigator display, select Edit, and continue to add columns.)
Column Name Type
Size
patron_id
NUMBER
last_name
VARCHAR2
30
first_name
VARCHAR2
30
street_address
VARCHAR2
30
city_state_zip
VARCHAR2
30

Primary Key. (Unique patron ID number, with
values to be created using a sequence that you
will create)
Not Null
The last column in the table (location) requires a complex data type, for which you
must use the Columns tab with advanced options. Check Show Advanced Options
(next to Schema). This displays additional tabs for more table options.
On the Columns tab, click the city_state_zip column name, and click the Add Column
(+) icon to add the following as the last column in the table.
Column Name Type
location
(Oracle Spatial geometry object representing the

patrons geocoded address)
Complex type
Schema: MDSYS
Type: SDO_GEOMETRY
After you have entered the last column (location), click OK to finish creating the table.
Go to Creating a Table (Transactions) to create the next table.
Related Topics
2.3 Creating a Table (Transactions)

The Transactions table contains a row for each transaction involving a patron and a
book (for example, someone checking a book out or returning a book). It includes two
foreign key columns. You will use the Create Table dialog box to create the table
declaratively; the table that you create will be essentially the same as if you had
entered the following statement using the SQL Worksheet:
CREATE TABLE Transactions (
transaction_id NUMBER PRIMARY KEY,
patron_id CONSTRAINT for_key_patron_id
REFERENCES patrons(patron_id),
book_id CONSTRAINT for_key_book_id
REFERENCES books(book_id),
transaction_date DATE,
transaction_type NUMBER);
To create the Transactions table, if you are not already connected, connect to the
database as the user for the schema you are using for this tutorial. Right-click the
Tables node in the schema hierarchy on the left side, select Create Table, and enter the
following information. (If a tab or field is not mentioned, do not enter anything for it.)
Name: Transactions
Create the table columns using the following information. After creating each column
except the last one (transaction_type), click Add Column to add the next column. (If
you accidentally click OK instead of Add Column, right-click the TRANSACTIONS
table in the Connections navigator display, select Edit, and continue to add columns.)
Column Name
Type
transaction_id
NUMBER
Primary Key. (Unique transaction ID number,

with values to be created using a trigger and
sequence that will be created automatically)
patron_id
NUMBER
(Foreign key; must match a patron_id value in

the Patrons table)
book_id
VARCHAR2 20
(Foreign key; must match a book_id value in

the Books table)
transaction_date
DATE
(Date and time of the transaction)
transaction_type NUMBER
Size
(Numeric code indicating the type of

transaction, such as 1 for checking out a book)
After you have entered the last column (transaction_type), check Show Advanced
Options (next to Schema). This displays additional tabs for more table options. For
this table, you will use the Primary Key and Foreign Keys tabs.
Primary Key tab
Because you have already specified the column for the primary key, you will use this
tab only to specify that the primary key column values are to be populated
automatically. This convenient approach uses a trigger and a sequence (both created
automatically by Raptor), and ensures that each transaction ID value is unique.
Populate Primary Key Column: TRANSACTION_ID
From: (Accept the defaults.)
Trigger Name: (Either accept the default or enter a name for the before-insert trigger
that will be created automatically.)
Foreign Keys tab
1. Click Add to create the first of the two foreign keys for the Transactions table.
Name: for_key_patron_id
Referenced Schema: Name of the schema containing the table with the primary key or
unique constraint to which this foreign key refers. Use the schema you have been
using for this tutorial.
Referenced Table: PATRONS
Referenced Constraint: Name (generated by Oracle) of the primary key constraint for
the Patrons table. (Might be a name with a format like PATRONS_PK.) Be sure that the
Referenced Column on PATRONS displayed value is PATRON_ID after you select the
Referenced Constraint.
Associations: Local Column: PATRON_ID
Associations: Referenced Column on PATRONS: PATRON_ID
2. Click Add to create the second of the two foreign keys for the Transactions table.
Creating a Sequence
Name: for_key_book_id
unique constraint to which this foreign key refers. Use the schema you have been
using for this tutorial.
Referenced Table: BOOKS
Referenced Constraint: Name (generated by Oracle) of the primary key constraint for
the Books table. (Might be a name with a format like BOOKS_PK.) Be sure that the
Referenced Column on BOOKS displayed value is BOOK_ID after you select the
Referenced Constraint.
Associations: Local Column: BOOK_ID
Associations: Referenced Column on BOOKS: BOOK_ID
3. Click OK to finish creating the table.
You have finished creating all the tables. To create a sequence for use in generating
unique primary key values for the Patrons table, go to Creating a Sequence.
Related Topics
2.4 Creating a Sequence

Create one sequence object, which will be used in INSERT statements to generate
unique primary key values in the Patrons table. (You do not need to create a sequence
for the primary key in the Transactions table, because you used the Raptor feature that
enables automatic population of primary key values for that table.) You will use the
Create Sequence dialog box to create the sequence declaratively; the sequence that you
create will be essentially the same as if you had entered the following statements using
the SQL Worksheet:
CREATE SEQUENCE patron_id_seq
START WITH 100
INCREMENT BY 1;
After creating the sequence, you can use it in INSERT statements to generate unique
numeric values. The following example uses the patron_id_seq sequence in creating a
row for a new patron (library user), assigning her a patron ID that is the next available
value of the patrons_id_seq sequence:
INSERT INTO patrons VALUES (patron_id_seq.nextval,
'Smith', 'Jane', '123 Main Street', 'Mytown, MA 01234', null);
To create the sequence, if you are not already connected, connect to the database as the
user for the schema you are using for this tutorial. Right-click the Sequences node in
the schema hierarchy on the left side, select Create Sequence, and enter information
using the Create Sequence dialog box.
Schema: Specify your current schema as the schema in which to create the sequence.
Name: patron_id_seq
Increment: 1
Start with: 100
Creating a View
Click OK to finish creating the sequence.

To create a view, go to Creating a View.
Related Topics
2.5 Creating a View

Create a view that returns information about patrons and their transactions. This view
queries the Patrons and Transactions tables, and returns rows that contain a patrons
ID, last name, and first name, along with a transaction and the transaction type. The
rows are ordered by patron ID, and by transaction type within patron IDs. You will use
the Create View dialog box to create the view declaratively; the view that you create
will be essentially the same as if you had entered the following statement using the
SQL Worksheet:
CREATE VIEW patrons_trans_view AS
SELECT p.patron_id, p.last_name, p.first_name,
t.transaction_type, t.transaction_date
FROM patrons p, transactions t
WHERE p.patron_id = t.patron_id
ORDER BY p.patron_id, t.transaction_type;
To create the patrons_trans_view view, if you are not already connected, connect to the
database as the user for the schema you are using for this tutorial. Right-click the
Views node in the schema hierarchy on the left side, select Create View, and enter the
following information. (If a tab or field is not mentioned, do not enter anything for it.)
Schema: Specify your current schema as the schema in which to create the view.
Name: patrons_trans_view
Quick-Pick Objects tab
Schema: Specify your current schema.
Click Filter Types, be sure that only Tables is checked, and click OK. (This limits the
display of available objects to tales.)
Click Query to populate the Available display.
In the Available list, find and expand the PATRONS node, and double-click each of
the following columns to move it to Selected in the following order: PATRON_ID, LAST_
NAME, FIRST_NAME
In the Available list, find and expand the TRANSACTIONS node, and double-click
each of the following columns to move it to Selected in the following order: PATRON_
ID, TRANSACTION_TYPE, TRANSACTION_DATE
FROM Clause tab
In Selected, click on PATRONS; then in Alias, enter: p
In Selected, click on TRANSACTIONS; then in Alias, enter: t
SELECT Clause tab
SELECT List: Click to select the fourth item (PATRON_ID1 (t.PATRON_ID)); then
click the Delete (X) icon, which deletes that item from the SELECT clause of the query
Creating a PL/SQL Procedure
used in the view definition. (That is, the patron_id value from the Transactions table is
not used for the view results, although it is needed for the WHERE clause.)
WHERE Clause
WHERE: Either type the following: p.patron_id = t.patron_id; or build the query using
the Expression Palette.
To use the Expression Palette, expand PATRONS, double-click PATRON_ID to move it
to the WHERE box; type an equal sign (=), optionally with a space before and after it;
click and expand TRANSACTIONS, double-click PATRON_ID to move it to the
WHERE box.
ORDER BY Clause
Click the Add (+) icon to add the first of two columns whose values will be used to
sort the results returned by the view.
In Expression Palette, expand PATRONS, double-click PATRON_ID to move it to the
Expression box.
Click the Add (+) icon to add the second of two columns whose values will be used to
sort the view results.
In Expression Palette, expand TRANSACTIONS, double-click TRANSACTION_TYPE
to move it to the Expression box.
DDL
Review the SQL statement that Raptor will use to create the view. If you want to make
any changes, go back to the relevant tabs and make the changes there.
If you want to save the CREATE VIEW statement to a SQL script file, click Save and
specify the location and file name.
When you are finished, click OK.
You have finished creating the view. To see the data returned by the view, in the
Connections navigator, expand Views, select PATRONS_TRANS_VIEW, and click the
Data tab.
Related Topics
2.6 Creating a PL/SQL Procedure

Create a procedure that lists all books with a specified rating. You can then call that
procedure with an input parameter (a number from 1 to 10), and the output will be all
the titles of all books with that rating.
To create the procedure, if you are not already connected, connect to the database as
the user for the schema you are using for this tutorial. Right-click the Procedures node
in the schema hierarchy on the left side, select Create Procedure, and enter the
following information using the Create PL/SQL Procedure dialog box.
Object Name: list_a_rating
Click OK. A Source window for the new procedure is opened. Enter (or copy and
paste) the following procedure text:
PROCEDURE list_a_rating(in_rating IN NUMBER) AS
Debugging a PL/SQL Procedure
matching_title VARCHAR2(50);
TYPE my_cursor IS REF CURSOR;
the_cursor my_cursor;
BEGIN
OPEN the_cursor FOR 'SELECT title FROM books WHERE
rating = :in_rating' USING in_rating;
DBMS_OUTPUT.PUT_LINE('All books with a rating of ' || in_rating || ':');
LOOP
FETCH the_cursor INTO matching_title;
EXIT WHEN the_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(matching_title);
END LOOP;
CLOSE the_cursor;
END;
This procedure uses a cursor (named the_cursor) to return only rows where the book
has the specified rating (in_rating parameter), and uses a loop to output the title of
each book with that rating.
Click the Save icon to save the procedure.
As a usage example, after creating the procedure named list_a_rating, you could use
the following statement to return all books with a rating of 10:
CALL list_a_rating(10);
To run this procedure within Database Designer, right-click LIST_A_RATING in the

Connections navigator hierarchy display and select Run. In the Run PL/SQL dialog
box, change IN_RATING => IN_RATING to IN_RATING => 10, and click OK. The
Log window display will now include the following output:
All books with a rating of 10:
Moby Dick
Software Wizardry
Related Topics
2.7 Debugging a PL/SQL Procedure

If you want to practice debugging a PL/SQL procedure with Raptor, create a
procedure that is like the list_a_rating procedure that you created in Creating a
PL/SQL Procedure, but with a logic error. (The coding is also deliberately inefficient,
to allow the display of the rating in a variable.)
To create this procedure, if you are not already connected, connect to the database as
the user for the schema you are using for this tutorial. Right-click the Procedures node
in the schema hierarchy on the left side, select Create New PL/SQL Procedure, and
enter the following information using the Create PL/SQL Procedure dialog box.
Object Name: list_a_rating2
Click OK. A Source window for the new procedure is opened. Enter (or copy and
paste) the following procedure text:
PROCEDURE list_a_rating2(in_rating IN NUMBER) AS
Debugging a PL/SQL Procedure
matching_rating NUMBER;
rating_cursor my_cursor;
BEGIN
rating <= :in_rating' USING in_rating;
OPEN rating_cursor FOR 'SELECT rating FROM books WHERE
rating <= :in_rating' USING in_rating;
LOOP
FETCH rating_cursor INTO matching_rating;
END LOOP;
CLOSE the_cursor;
CLOSE rating_cursor;
END;
This procedure contains a logic error in the definition of the_cursor: it selects titles
where the rating is less than or equal to a specified rating, whereas it should select
titles only where the rating is equal to the specified rating.
Click the Save icon to save the procedure.
Assume that you wanted to run this procedure and list all books with a rating of 10.
Right-click LIST_A_RATING2 in the Connections navigator hierarchy display and
select Run. In the Run PL/SQL dialog box, change IN_RATING => IN_RATING to
IN_RATING => 10, and click OK. In the Log window, however, you see unexpected
output: many titles are listed, including some with ratings other than 10. So, you
decide to debug the procedure.
To debug the procedure, follow these steps:
1.
Set two breakpoints by clicking in the left margin (left of the thin vertical line)
beside each of these two lines: FETCH the_cursor INTO matching_title;
and FETCH rating_cursor INTO matching_rating;. (Clicking in the left
margin toggles the setting and unsetting of breakpoints.) This will enable you to
see the values of the matching_title and matching_rating variables as execution
proceeds in debug mode.
2.
Right-click LIST_A_RATING2 in the Connections navigator hierarchy display and

select Debug. Ensure that the line IN_RATING => IN_RATING has been changed
to IN_RATING => 10, and click OK.
3.
In the debugging toolbar, click the Resume icon to have execution proceed,
stopping at the next breakpoint; note the display in the Smart Data tab in the
lower right part of the window. Repeatedly click the Resume icon, noticing
especially the value of the rating variable as each row is processed. You will notice
the first incorrect result when you see that the title Get Rich Really Fast is included,
even though its rating is only 1 (obviously less than 10). (See the screen illustration
with debugging information in Running and Debugging Functions and
Procedures.)
4.
When you have enough information to fix the problem, you can click the
Terminate icon in the debugging toolbar.
From this debugging session, you know that to fix the logic error, you should change
rating <= :in_rating to rating = :in_rating in the definition of the_cursor.
Related Topics
Run/Debug PL/SQL (dialog box)
2.8 Using the SQL Worksheet for Queries

You can use the SQL Worksheet to test SQL statements using a database connection. To
display the worksheet, from the Tools menu, select SQL Worksheet. In the Select
Connection dialog box, select the database connection that you used to create the
Books, Patrons, and Transactions (see Tutorial: Creating Objects for a Small Database).
The SQL Worksheet has the user interface shown in Using the SQL Worksheet.
In the Enter SQL Statement box, enter the following statement (the semicolon is
optional for the SQL Worksheet):
SELECT author_last_name, title FROM books;
Notice the automatic highlighting of SQL keywords (SELECT and FROM in this
example).
Click the Execute SQL Statement icon in the SQL Worksheet toolbar. The results of the
query are displayed on the Results tab under the area in which you entered the SQL
statement.
In the Enter SQL Statement box, enter (or copy and paste) the following statement,
which is the same as the SELECT statement in the view you created in Creating a
View:
Click the Execute SQL Statement icon in the SQL Worksheet toolbar, and view the
results of the query.
Click the Explain tab to see the execution plan that Oracle Database follows to execute
the SQL statement. The information includes the optimizer strategy and the cost of
executing the statement. (For information about how to generate and interpret
execution plans, see Oracle Database Performance Tuning Guide.)
Related Topics
2.9 Script for Creating and Using the Library Tutorial Objects
The following statements create and use the database objects that you have created (or
will create) in Tutorial: Creating Objects for a Small Database. You can view these
commands to help you understand the library database objects that are covered in the
tutorial.
-- Clean up from any previous running
DROP TABLE transactions;
DROP
DROP
DROP
DROP
DROP
TABLE books;
TABLE patrons;
SEQUENCE patron_id_seq;
SEQUENCE trans_id_seq;
VIEW patrons_trans_view;
set serveroutput on
-- Create objects
CREATE TABLE Books (
book_id VARCHAR2(20) PRIMARY KEY,
title VARCHAR2(50)
CONSTRAINT title_not_null NOT NULL,
author_last_name VARCHAR2(30)
CONSTRAINT last_name_not_null NOT NULL,
author_first_name VARCHAR2(30),
rating NUMBER,
CONSTRAINT rating_1_to_10 CHECK (rating IS NULL OR
(rating >= 1 and rating <= 10)),
CONSTRAINT author_title_unique UNIQUE (author_last_name, title));
CREATE TABLE Patrons (
patron_id NUMBER PRIMARY KEY,
last_name VARCHAR2(30)
CONSTRAINT patron_last_not_null NOT NULL,
first_name VARCHAR2(30),
street_address VARCHAR2(50),
city_state_zip VARCHAR2(50),
location MDSYS.SDO_GEOMETRY);
CREATE TABLE Transactions (
transaction_id NUMBER PRIMARY KEY,
patron_id CONSTRAINT for_key_patron_id
REFERENCES patrons(patron_id),
book_id CONSTRAINT for_key_book_id
REFERENCES books(book_id),
transaction_date DATE
CONSTRAINT tran_date_not_null NOT NULL,
transaction_type NUMBER
CONSTRAINT tran_type_not_null NOT NULL);
CREATE SEQUENCE patron_id_seq
START WITH 100
INCREMENT BY 1;
-- The actual sequence for the transaction_id
-- in the tutorial is created automatically,
-- and probably has a name in the form MDRS_xxx$.
CREATE SEQUENCE trans_id_seq
START WITH 1
INCREMENT BY 1;
CREATE OR REPLACE TRIGGER ins_transactions
BEFORE INSERT ON TRANSACTIONS
FOR EACH ROW
BEGIN
SELECT trans_id_seq.nextval INTO
:new.TRANSACTION_ID FROM dual;
END;
/
CREATE VIEW patrons_trans_view AS
-- Procedure: List all books that have a specified rating.
CREATE OR REPLACE PROCEDURE list_a_rating(in_rating IN NUMBER) AS
BEGIN
rating = :in_rating' USING in_rating;
LOOP
END LOOP;
CLOSE the_cursor;
END;
/
show errors;
-- Insert and query data.
INSERT
INSERT
INSERT
null);
INSERT
5);
INSERT
INTO books VALUES ('A1111', 'Moby Dick', 'Melville', 'Herman', 10);

INTO books VALUES ('A2222', 'Get Rich Really Fast', 'Scammer', 'Ima', 1);
INTO books VALUES ('A3333', 'Finding Inner Peace', 'Blissford', 'Serenity',
INTO books VALUES ('A4444', 'Great Mystery Stories', 'Whodunit', 'Rodney',
INTO books VALUES ('A5555', 'Software Wizardry', 'Abugov', 'D.', 10);

'Smith', 'Jane', '123 Main Street', 'Mytown, MA 01234', null);
'Chen', 'William', '16 S. Maple Road', 'Mytown, MA 01234', null);
'Fernandez', 'Maria', '502 Harrison Blvd.', 'Sometown, NH 03078', null);
'Murphy', 'Sam', '57 Main Street', 'Mytown, MA 01234', null);
INSERT INTO transactions (patron_id, book_id,
transaction_date, transaction_type)
VALUES (100, 'A1111', SYSDATE, 1);
-- Test the view and the procedure.
SELECT * FROM patrons_trans_view;
CALL list_a_rating(10);
3
Raptor uses dialog boxes for creating and editing database connections and objects in
the database (tables, views, procedures, and so on). The dialog boxes sometimes have
multiple tabs, each reflecting a logical grouping of properties for that type of object.
For an explanation of any dialog box or tab, click the Help button or press the F1 key.
The dialog boxes are not presented here in any rigorous order, because the help for
each box is an independent piece of information and is normally seen when you click
Help or press F1 in that box.
For all Name fields, any name that you type is automatically
converted to and stored in the database metadata in uppercase, unless
you enclose the name in quotation marks (" "). (Names of database
objects in SQL and PL/SQL statements are not case-sensitive.)
Note:
To include lowercase characters, special characters, or spaces in object

names, enclose the name in quotation marks (" ") when you type it.
Example: "My table"
Related Topics
Database Objects
3.1 Add Extension

This dialog box is displayed when you click Add in the File Types pane of Raptor
Preferences.
Extension: Specify the file extension, including the period (for example, .xyz).
After you click OK, you can select that extension and modify its details, including the
file type, content type, and whether to have files of the extension automatically opened
by Raptor.
3.2 Apply Filter

Filter Text: Limits the display of objects available for selection according to a character
string in the name, with the percent sign (%) as a wildcard character. The search for
matching names is not case sensitive. For example, to limit the display of objects to
those whose names start with the string EM, specify the following filter text: EM%
Dialog Boxes for Creating/Editing Objects 3-1
Check for Updates
3.3 Check for Updates

When you click Help and then Check for Updates, you can check for and download
available Raptor updates. The following pages may be displayed:
1.
Source: Select the source or sources to be checked for available updates: any or all
of some specified online update centers, or a local ZIP file containing an update
bundle.
2.
Update: If any updates are available from the selected source or sources, select
those that you want to download.
3.
Download: If you selected any updates to download, this page displays the
progress of the download operation.
3.4 Choose Directory

This is a standard box for choosing a directory in which to place files: use Location to
navigate to (double-clicking) the folder in which to save the files, or enter a directory
name. If the directory does not already exist, it is created.
3.5 Create/Edit New Object

Specify the type of object to create. After you click OK, the dialog box for creating that
type of object is displayed.
Filter By: Available Items displays the types of objects that you can create in the
current database connection; All Items displays all types of objects (some of which
may not be available for selection).
Categories: A hierarchical display of categories of objects.
Items: Types of objects that you can create within the selected category.
Related Topics
Database Objects
3.6 Create/Edit/Select Database Connection

The database connection dialog box displays any existing connections. Depending on
the context, you can select a connection to connect to the database, edit the information
about existing connections, or specify information while creating a new connection.
(See Creating and Editing Connections.)
Raptor internally constructs a SQL*Plus CONNECT statement based on information
you enter in this dialog box.
Connection Name: An alias for a connection to the database using the information
that you enter. (The connection name is not stored in the database, and the connection
is not a database object.) Suggestion: Include the database name (SID) and user name
in the connection name. Example: personnel_herman for connecting to the personnel
database as user Herman.
Username: Name of the database user for the connection. This user must have
sufficient privileges to perform the tasks that you want perform while connected to the
database, such as creating, editing, and deleting tables, views, and other objects.
Password: Password associated with the specified database user.
Select Connection
Role: The set of privileges to be associated with the connection. For a user that has
been granted SYSOPER or SYSDBA system privilege, you can specify a connection
that includes the privilege.
Basic tab
Host Name: Host system for the Oracle database.
Port: Listener port.
SID: Database name.
Service Name: Network service name of the database (for a remote database
connection over a secure connection).
TNS tab
Network Alias: Oracle Net alias for the database. (The list for selecting a network alias
is initially filled from the tnsnames.ora file on your system, if that file exists.)
Connect Identifier: Oracle Net connect identifier.
Advanced tab
Custom JDBC URL: URL for connecting from Java to the database.
Creating and Editing Connections
To create a new connection when no connections exist, enter the connection information
and click Connect. To test the connection before you create it, click Test.
To create a new connection when one or more connections already exist, click New, enter the
connection information, and click Connect. To test the connection before you create it,
click Test.
To edit an existing connection, click in its entry in the Connection Name column, change
any property values on the left side, and click Connect. To test the connection before
you save changes to it, click Test.
Related Topics
3.7 Select Connection

Use this box to select a database connection for use with a specific Raptor feature (for
example, the SQL worksheet or the Reports navigator). After you click OK, the
interface for the component is displayed , with the current user the same as the one
specified in the connection.
To create a new database connection, click New; to edit the selected database
connection, click Edit. In both cases, a dialog box for specifying connection
information is displayed (see Create/Edit/Select Database Connection).
Related Topics
Select Library
3.8 Select Library

This dialog box is displayed when you click Browse in the Database Connections pane
when setting Raptor Preferences. Use this box to select the library for the specified
JDBC driver class.
Related Topics
3.9 Create Library

This dialog box is displayed when you click New in the Select Library dialog box,
which is displayed when you click Browse in the Database Connections pane when
setting Raptor Preferences. Use this box to create the library for the specified JDBC
driver class.
Related Topics
3.10 Export/Import Connection Descriptors

The Export Connection Descriptors dialog box exports information about one or more
database connections to an XML file. The Import Connection Descriptors dialog box
imports connections that have been exported. Connections that you import are added
to any connections that already exist in Raptor.
File Name: Name of the XML file to contain exported information or that contains
information to be imported. Use the Browse button to specify the location.
Connections: Names of connections that you can select for the export or import
operation.
Related Topics
3.11 Create/Edit Database Link

The following information applies to a database link, which is a database object in one
database that enables you to access objects on another database, as explained in
Database Links.
Schema: Database schema in which to create the database link.
Name: Name of the database link. Must be unique within a schema.
Service Name: The service name of a remote database. If you specify only the database
name, Oracle Database implicitly appends the database domain to the connect string
to create a complete service name. Therefore, if the database domain of the remote
database is different from that of the current database, you must specify the complete
service name.
Current User: Creates a current user database link. The current user must be a global
user with a valid account on the remote database. If the database link is used directly,
that is, not from within a stored object, then the current user is the same as the
connected user.
Create/Edit Index
Fixed User: Creates a fixed user database link, for which you specify the user name
and password used to connect to the remote database.
Public: If this option is checked, the database link is public (available to all users). If
this option is not checked, the database link is private and is available only to you.
Shared: If this option is checked, a single network connection is used to create a public
database link that can be shared among multiple users. In this case, you must also
specify the Authentication information.
Authentication - User Name and Password: The user name and password on the
target instance. This information authenticates the user to the remote server and is
required for security. The specified user and password must be a valid user and
password on the remote instance.
DDL tab
You can review and save the SQL statement that Raptor will use to create a new
database link or that reflects any changes you have made to the database link
properties.
Related Topics
Database Objects
3.12 Create/Edit Index

The following information applies to an index, which is a database object that contains
an entry for each value that appears in the indexed column(s) of the table or cluster
and provides direct, fast access to rows, as explained in Indexes.
Schema: Database schema that owns the table associated with the index.
Table: Name of the table associated with the index.
Name: Name of the index. Must be unique within a schema.
Index Type: Normal for a standard Oracle index, in which case you also specify
non-unique, unique, or bitmap, as well as one or more index expressions; or Text for
an Oracle Text index, in which case you specify the column to be indexed.
Non-unique means that the index can contain multiple identical values; Unique
means that no duplicate values are permitted; Bitmap stores rowids associated with a
key value as a bitmap.
Index Expressions: Lists the columns or expressions currently in the index. To add an
entry, click the Add Column Expression (+) icon; to delete a column, select it and click
the Remove Column Expression (X) icon; to move a column expression up or down in
the index definition, select it and use the up-arrow and down-arrow keys.
Column Expression: The column or expression associated with the selected index
expression.
Order: ASC to store the index values in ascending order; DESC to store the index
values in descending order.
Related Topics
Database Objects
Create PL/SQL Function, Procedure, or Package

3.13 Create PL/SQL Function, Procedure, or Package

Specify the following information for a PL/SQL subprogram (function or procedure)
or a package to contain subprograms.
Object Name: Name of the object. Must be unique within a schema.
Object Type (if you have specified PL/SQL Subprogram and not a specific type of
object): One of the following object types:
FUNCTION: a function (returns a value)
PROCEDURE: a procedure (does not return a value)
PACKAGE: a package that can contain multiple functions or procedures, or a

combination of functions and procedures
The object is created and is displayed in the Editor window, where you can enter the
details.
For information about PL/SQL subprograms, see Subprograms and Packages: Usage
Information.
Related Topics
Database Objects
3.14 Create/Edit Sequence

The following information applies to a sequence, which is an object from which
multiple users may generate unique integers. You can use sequences to automatically
generate primary key values.
Schema: Database schema in which to create the sequence.
Name: Name of the sequence. Must be unique within a schema.
Increment: Interval between successive numbers in a sequence.
Start with: Starting value of the sequence.
Min value: Lowest possible value for the sequence. The default is 1 for an ascending
sequence and -(10^26) for a descending sequence.
Max value: Highest possible value for the sequence. The default is 10^27 for an
ascending sequence and -1 for a descending sequence.
Cycle: Indicates whether the sequence "wraps around" to reuse numbers after reaching
its maximum value (for an ascending sequence) or its minimum value (for a
descending sequence). If cycling of values is not enabled, the sequence cannot generate
more values after reaching its maximum or minimum value.
Cache and Cache size: If Cache is checked, sequence values are preallocated in cache,
which can improve application performance; Cache size indicates the number of
sequence values preallocated in cache. If Cache is not checked, sequence values are not
preallocated in cache.
Create Table (quick creation)
Order: Indicates whether sequence numbers are generated in the order in which they
are requested. If no ordering is specified, sequence numbers are not guaranteed to be
in the order in which they were requested.
DDL tab
You can review the SQL statement that Raptor will use to create a new sequence or
that reflects any changes you have made to the sequence properties.
For information about sequences, see Managing Sequences.
Related Topics
Database Objects
3.15 Create/Edit Synonym

The following information applies to a synonym, which is an alternative name for a
table, view, sequence, procedure, stored function, package, materialized view, Java
class database object, user-defined object type, or another synonym.
Public: If this option is checked, the synonym is accessible to all users. (However each
user must have appropriate privileges on the underlying object in order to use the
synonym.) If this option is not checked, the synonym is a private synonym, and is
accessible only within its schema.
Schema: Database schema in which to create the synonym.
Name: Name of the synonym. A private synonym must be unique within its schema; a
public synonym must be unique within the database.
For - Referenced Schema: Schema containing the object or name to which this
synonym refers.
Object Based: Specify the object to which this synonym refers.
Name Based: Enter the name of the object to which this synonym refers.
DDL tab
You can review the SQL statement that Raptor will use to create a new synonym or
that reflects any changes you have made to the synonym properties.
For information about synonyms, see Managing Synonyms.
Related Topics
Database Objects
3.16 Create Table (quick creation)

This dialog box (if you do not check Show Advanced Options) creates a new table
quickly by specifying columns and some frequently used features. (If you need to add
or change features after you create the table, you can edit the table by clicking the
Modify icon while viewing the table or by right-clicking its name in the Connections
Create Table (quick creation)
navigator and selecting Properties, which displays the Create/Edit Table (with
advanced options) dialog box.)
Show Advanced Options: If this option is checked, the dialog box changes to one with
multiple tabs, in which you can specify an extended set of features while creating the
table.
Schema: Database schema in which to create the table.
Name: Name of the table. Must be unique within a schema.
Columns tab (quick creation)
Specifies properties for each column in the table.
Columns: Lists the columns currently in the table.
To add a column after the currently selected column, click Add
Column; to delete a column, select it and click Remove Column.
Note:
Column Name: Name of the column. Must be unique within the table. Suggestion: For
a new column, replace any default name, such as COLUMN1.
Type: Data type for the column. The drop-down list includes only selected frequently
used data types. To specify any other type for the column, you must use the Columns
tab of the Create/Edit Table (with advanced options) dialog box.
Size: For VARCHAR2 data, the maximum size of the column data; for NUMBER data,
the maximum number of digits.
Not Null: If this option is checked, the column must contain data; you cannot specify
no value or an explicit null value for this column when you insert a row. If this option
is not checked, the column can contain either data or no data.
Primary Key: If this option is checked, the column is the primary key, or part of the
primary key, for the table. The primary key is the column, or set of columns, that
uniquely identifies each row in the table. A primary key column cannot be null.
If you want to have the primary key values automatically populated by a convenient
method that uses a before-insert trigger and a sequence, then before you finish
creating the table, you must check Show Advanced Options and use the Primary Key
tab, starting with the Populate Primary Key Column field.
To add another column, click Add Column. When you are finished adding columns,
either click OK or click the DDL tab to review the CREATE TABLE statement.
DDL tab (quick creation)
You can review and save the CREATE TABLE statement that Raptor will use to create
a new table or that reflects any changes you have made to the table properties. If you
want to make any changes, go back to the Columns tab and make the changes there.
Related Topics
Create/Edit Table (with advanced options) (dialog box including advanced features)
Database Objects
Create/Edit Table (with advanced options)
3.17 Create/Edit Table (with advanced options)

The table dialog box is used for creating a new table or editing an existing table. The
table properties are grouped under several tabs.
To create a new table, the only things you must do are specify the schema and the table
name, add the necessary columns, and click OK. Although it is not required, you
should also specify a primary key using the Primary Key tab. For other table-related
features, use the appropriate tabs; the order in which you visit tabs usually does not
matter, although you might find it convenient to visit them in the sequence in this
topic. If you are editing an existing table, you can visit the tabs in any order.
If you click OK before you are finished creating or editing the table, right-click the
table name in the Connections navigator, select Edit, and continue creating or editing
the table.
Schema: Database schema in which to create the table.
Name: Name of the table. Must be unique within a schema.
Columns tab
Specifies properties for each column in the table.
Columns: Lists the columns currently in the table. To add a column, click the Add
Column (+) icon; to delete a column, select it and click the Remove Column (X) icon; to
move a column up or down in the table definition, select it and use the up-arrow and
down-arrow keys.
After you add a column, to add another column, click the Add
Column (+) icon.
Note:
Name: Name of the column. Must be unique within the table. Suggestion: For a new
column, replace any default name, such as COLUMN1.
Datatype: Simple indicates a simple (non-object) data type; Complex indicates an
object type. For a complex type, you must specify the schema and the type name (for
example, MDSYS and SDO_GEOMETRY for the Oracle Spatial geometry type).
Type: Name of the data type. Most of the remaining information depends on the
specific type.
Precision: For numeric data, the precision (total number of significant digits that can
be represented) of the column data.
Scale: For numeric data, the scale (number of digits after the decimal point) of the
column data.
Size: For character data, the maximum size of the column data.
Units: For character data, the units represented by the Size: BYTE for bytes or CHAR
for characters. This attribute is important if the database can contain data in Unicode
format, with multiple bytes for each character.
Default: For relevant types, the default value inserted into the column if no value is
specified when a row is inserted.
Cannot be NULL: If this option is checked, the column must contain data; you cannot
specify no value or an explicit null value for this column when you insert a row. If this
option is not checked, the column can contain either data or no data. A primary key
column (see Primary Key tab) cannot be null.
Comment: Optional descriptive comment about the column.

To add another column, click the Add Column (+) icon.
Primary Key tab
Specifies the primary key for the table. The primary key is the column, or set of
columns, that uniquely identifies each row in the table.
An index is automatically created on the primary key.
Name: Name of the constraint to be associated with the primary key definition. Must
be unique within the database.
Enabled: If this option is checked, the primary key constraint is enforced: that is, the
data in the primary key column (or set of columns) must be unique and not null.
Available Columns: Lists the columns that are available to be added to the primary
key definition.
Selected Columns: Lists the columns that are included in the primary key definition.
To add a column to the primary key definition, select it in Available Columns and click
the Add (>) icon; to remove a column from the primary key definition, select it in
Selected Columns and click the Remove (<) icon. To move all columns from available
to selected (or the reverse), use the Add All (>>) or Remove All (<<) icon. To move a
column up or down in the primary key definition, select it in Selected Columns and
use the arrow keys.
The remaining fields (Populate Primary Key Column through Trigger Name) appear
only when you are creating a table. They are not available when you are editing an
existing table.
Populate Primary Key Column: When you are creating a table, if you want to use a
trigger and a sequence to have a unique value automatically inserted into the primary
key column when you insert a new row, specify the primary key column.
From: An existing sequence that you select, or a new sequence whose name you enter.
(For a new sequence, Raptor creates the sequence automatically using the name that
you enter.)
Trigger Name: The name for the before-insert trigger that will be automatically
created. This trigger uses the sequence to generate a new value for the primary key
when a row is inserted. For an example of using this technique, see the tutorial section
Creating a Table (Transactions).
Unique Constraints tab
Specifies one or more unique constraints for the table. A unique constraint specifies a
column, or set of columns, whose data values must be unique: each data value must
not be null, and it must not be the same as any other value in the column.
For a multicolumn unique constraint, the combination of values must be unique, and
no column in the constraint definition can have a null value. For example, if you
specify the office_name and city columns for a unique constraint, you could not have
two Sales offices in Chicago, but you could have a Sales office in Chicago and a Sales
office in Atlanta.
Unique Constraints: Lists the unique constraints currently defined on the table. To
add a unique constraint, click the Add button; to delete a unique constraint, select it
and click the Remove button.
Note: After you add a unique constraint, to add another unique

constraint, click the Add button.
Name: Name of the unique constraint. Must be unique within the database.
Enabled: If this option is checked, the unique constraint is enforced.
Available Columns: Lists the columns that are available to be added to the unique
constraint definition.
Selected Columns: Lists the columns that are included in the unique constraint
definition.
To add a column to the unique constraint definition, select it in Available Columns and
click the Add (>) icon; to remove a column from the unique constraint definition,
select it in Selected Columns and click the Remove (<) icon. To move all columns from
available to selected (or the reverse), use the Add All (>>) or Remove All (<<) icon. To
move a column up or down in the unique constraint definition, select it in Selected
Columns and use the arrow keys.
Foreign Keys tab
Specifies one or more foreign keys for the table. A foreign key specifies a column
("local column"), each of whose data values must match a value in the primary key or
unique constraint of another table.
Foreign Keys: Lists the foreign keys currently defined on the table. To add a foreign
key, click the Add button; to delete a foreign key, select it and click the Remove button.
Note: After you add a foreign key, to add another foreign key, click
the Add button.
Name: Name of the foreign key definition. Must be unique within the database.
Enabled: If this option is checked, the foreign key is enforced.
unique constraint to which this foreign key refers.
Referenced Table: Name of the table with the primary key or unique constraint to
which this foreign key refers.
Referenced Constraint: Name of the primary key or unique constraint to which this
foreign key refers.
Associations: Local Column: Lists the column in the currently selected (local) table
that is included in the foreign key definition. For each local column in the foreign key
definition, select the name of a column in the local table.
Associations: Referenced Column on [table]: For each local column, identifies the
column in the other (foreign) table that must have a value matching the value in the
local column.
Check Constraints tab
Specifies one or more check constraints for the table. A check constraint specifies a
condition that must be met when a row is inserted into the table or when an existing
row is modified.
Check Constraints: Lists the check constraints currently defined on the table. To add a
check constraint, click the Add button; to delete a check constraint, select it and click
the Remove button.
After you add a check constraint, to add another check
constraint, click the Add button.
Note:
Name: Name of the check constraint definition. Must be unique within the database.
Enabled: If this option is checked, the check constraint is enforced.
Condition: Condition that must be met for a row. Can be any valid WHERE clause
(without the WHERE keyword) for a SELECT statement. For example, to indicate that
the value in a numeric column named RATING must be from 1 to 10, you can specify:
rating >=1 and rating <= 10
To add another check constraint, click the Add button.
Indexes tab
Specifies properties for each index on the table.
Indexes: Lists the indexes currently defined on the table. To add an index, click the
Add Index (+) icon; to delete an index, select it and click the Remove Index (X) icon.
After you add an index, to add another index, click the Add
Index (+) icon.
Note:
Name: Name of the index. Must be unique within the schema.

Index Expressions: The table columns or column expressions in the index. To add an
index expression, click the Add Column Expression (+) icon; this adds a column name
here and in Column Expression, where you can edit it. To delete an index expression,
click the Remove Column Expression (X) icon; to move an index expression up or
down in the list click the Move Column Up and Move Column Down icons.
Column Expression: A column name or column expression. A column expression is
an expression built from columns, constants, SQL functions, and user-defined
functions. When you specify a column expression, you create a function-based index.
Order: ASC for an ascending index (index values sorted in ascending order); DESC for
a descending index (index values sorted in descending order).
Storage Options tab
Specifies storage options for the table, enabling you to override the default storage
options.
Tablespace: Name of the tablespace for the table.
Pct Free: Percentage of space in each of the data blocks of the table reserved for future
updates to the rows of the table. You can enter a value from 0 through 99.
Pct Used: Minimum percentage of used space that Oracle maintains for each data
block of the table. A block becomes a candidate for row insertions when its used space
falls below the Pct Used value. You can enter a value from 1 through 99.
Extents - Initial: Size of the first extent of the table. Specify K (kilobytes) or M
(megabytes) for the unit associated with the number.
Extents - Next: Size of the next extent to be allocated to the table. Specify K (kilobytes)
or M (megabytes) for the unit associated with the number.
Extents - Min: Minimum number of extents allocated when the table is created.
Extents - Max: Maximum number of extents allocated when the table is created.
Unlimited (if checked) means that there is no maximum (and any specified maximum
is ignored).
Pct Increase: Percentage that each extent grows over the previous extent.
Ini Trans: Number of update transaction entries for which space is initially reserved in
the data block header.
Max Trans: Number of transaction entries that could concurrently use data in a data
block. This parameter has been deprecated. Oracle Database now automatically allows
up to 255 concurrent update transactions for any data block, depending on the
available space in the block.
Free Lists - Lists: Number of free lists for each of the free list groups for the table. The
default and minimum value for this parameter is 1, meaning that each free list group
contains one free list.
Free Lists - List Groups: Number of groups of free lists for the table. The default and
minimum value for this parameter is 1. Oracle uses the instance number of Real
Application Clusters instances to map each instance to one free list group.
Buffer Pool: <DEFAULT> means to use the Oracle Database default. KEEP means to
put blocks from the segment into the Keep buffer pool; maintaining an appropriately
sized Keep buffer pool lets Oracle retain the database object in memory to avoid I/O
operations. RECYCLE means to put blocks from the segment into the Recycle pool; an
appropriately sized Recycle pool reduces the number of objects whose default pool is
the Recycle pool from taking up unnecessary cache space.
Logging: <DEFAULT> means to use the Oracle Database default. ON means that the
table creation and any subsequent direct loader (SQL*Loader) and direct-path INSERT
operations against the table, partition, or LOB storage are logged in the redo log file.
OFF means that these operations are not logged in the redo log file.
DDL tab
You can review and save the CREATE TABLE statement that Raptor will use to create
a new table or that reflects any changes you have made to the table properties. If you
want to make any changes, go back to the relevant tabs and make the changes there.
To save the SQL statement to a script file, click Save and specify the location and file
name.
Related Topics
Create Table (quick creation) (dialog box with limited features)
Database Objects
Create/Edit Trigger
3.18 Create/Edit Trigger

The following information applies to a trigger, which is which is a stored PL/SQL
block associated with a table, a schema, or the database, or an anonymous PL/SQL
block or a call to a procedure implemented in PL/SQL or Java. The trigger is
automatically executed when the specified conditions occur.
Trigger Owner: Database schema in which to create the trigger.
Name: Name of the trigger. Must be unique within the database.
Trigger Type: The type of object on which to create the trigger: TABLE, VIEW,
SCHEMA, or DATABASE. (The remaining items depend on the type of trigger.)
Table Owner or View Owner: For a trigger on a table or a view, the name of the owner
of the table or the view.
Table Name or View Name : For a trigger on a table or a view, the name of the table or
the view.
Before or After: For a trigger on a table, select Before to cause the database to fire the
trigger before executing the triggering event, or select After to cause the database to
fire the trigger after executing the triggering event.
Statement Level or Row Level: For a trigger on a table, Statement Level fires the
trigger once before or after the triggering statement that meets the optional trigger
constraint defined in the WHEN condition; Row Level fires the trigger once for each
row that is affected by the triggering statement and that meets the optional trigger
constraint defined in the WHEN condition.
Insert, Update, Delete: For a trigger on a table or a view, Insert fires the trigger
whenever an INSERT statement adds a row to a table or adds an element to a nested
table; Update fires fire the trigger whenever an UPDATE statement changes a value in
one of the columns specified in Selected Columns (or in any column if no columns are
specified); Delete fires the trigger whenever a DELETE statement removes a row from
the table or removes an element from a nested table.
Referencing - Old: For a trigger on a table, the correlation names in the PL/SQL block
and WHEN condition of a row trigger to refer specifically to old value of the current
row.
Referencing - New: For a trigger on a table, the correlation names in the PL/SQL
block and WHEN condition of a row trigger to refer specifically to new value of the
current row.
Available Columns: For a trigger on a table, lists the columns from which you can
select for use in an Update trigger definition.
Selected Columns: For a trigger on a table, lists the columns used in an Update trigger
definition.
When: For a trigger on a table, an optional trigger condition, which is a SQL condition
that must be satisfied for the database to fire the trigger. This condition must contain
correlation names and cannot contain a query.
Schema: For a trigger on a schema, the name of the schema on which to create the
trigger.
Available Events: For a trigger on a schema or database, lists events from which you
can select for use in the trigger definition.
Selected Events: For a trigger on a schema or database, lists events used in the trigger
definition.
Create/Edit User Defined Report
For more information about triggers, see Triggers: Usage Information.

Related Topics
Database Objects
3.19 Create Type (User-Defined)

This dialog box is displayed when you right-click Types in the Connections navigator
and select Create Type to create a user-defined type. After you complete the
information in this dialog box and click OK, a SQL Worksheet is displayed in which
you must specify the appropriate definition of the type.
Schema: Database schema in which to create the type.
Name: Name of the type. Must be unique within its schema.
Type: Select the type of data type to be created: array type, object type specification,
object type specification and type body, or table type.
For more information about creating a user-defined type, see the CREATE TYPE
statement in Oracle Database SQL Reference. For information about Oracle-supplied
types, see Data Types: Usage Information.
Related Topics
Database Objects
3.20 Create/Edit User Defined Report

The following information applies to a user-defined report. For information about how
to create a user-defined report, see User Defined reports.
Name: Name of the user-defined report.
Description: Optional description of the report.
ToolTip: Optional tool tip text to be displayed when the mouse pointer stays briefly
over the report name in the Reports navigator display.
SQL Statement: The complete SQL statement for retrieving the information to be
displayed in the user-defined report. As a trivial example, the statement SELECT user
"Current User" FROM DUAL; displays Current User as the heading and the name of
the user associated with the current database connection.
Suggestion: Look at the SQL statements for various Raptor-supplied reports; check the
Messages - Log pane below the report results, or click the SQL icon under the Report
Results tab.
Related Topics
Reports
User Defined reports
Create/Edit User Defined Report Folder
3.21 Create/Edit User Defined Report Folder

The following information applies to a folder for organizing user-defined reports. Each
folder can contain reports and other folders (subfolders). For example, you can create a
folder named Sales, and then under that folder create folders named Sales by District
and Sales by Product.
For information about how to create user-defined reports and folders for these reports,
see User Defined reports.
Name: Name of the folder.
Description: Optional description of the folder.
ToolTip: Optional tool tip text to be displayed when the mouse pointer stays briefly
over the folder name in the Reports navigator display.
Related Topics
Reports
User Defined reports
3.22 Create/Edit View

The view dialog box is used for creating a new view or editing an existing view. The
view properties are grouped under several tabs.
If you are creating or editing a view, you can visit the tabs in any order; however, if
you are creating a new view, you might find it convenient to visit them in the sequence
in this topic.
If you click OK before you are finished creating or editing the view, right-click the
view name in the Connections navigator, select Edit, and continue creating or editing
the view.
Schema: Database schema in which to create the view.
Name: Name of the view. Must be unique within a schema.
Quick-Pick Objects tab
Specifies objects that you can use in the SELECT, FROM, and WHERE clauses of the
view definition. Identify the tables and views on which this view is based, and the
columns in those tables and views that are used in the definition of this view. To see
the results of your quick-pick specification, either check Auto-Query or click Query.
Schema: Database schema containing the objects to be selected.
Type Filter - Filter Types: Limits the display of objects available for selection to certain
types of database objects (for example, to show only tables or views).
Name Filter: Limits the display of objects available for selection according to a
character string in the name, with the percent sign (%) as a wildcard character. For
example, to limit the display of available tables and views to those whose names start
with the string EM, specify the following name filter: EM%
Auto-Query: If this option is enabled, the display of available objects is automatically
refreshed when you specify or change the Type Filter or Name Filter value.
Query: Refreshes the display of available objects based on the Type Filter and Name
Filter values.
Create/Edit View
Available: Lists the objects (typically, tables and views in a hierarchical display) from
which you can select objects to use in the SELECT, FROM, and WHERE clauses of the
view definition.
Selected: Lists the objects (typically, columns) that you can use in the SELECT, FROM,
and WHERE clauses of the view definition.
To add an object as selected, select it in Available and click the Add (>) icon; to remove
an object as selected, select it in Selected and click the Remove (<) icon. To move all
objects from selected to available, use the Remove All (<<) icon. To move an object up
or down in the selected list, select it in Selected and use the arrow keys.
For the example for the DDL tab, select the DEPTNO and SAL columns from the EMP
table.
View Information or Materialized View Information tab
Options for a standard view (View Information tab):
Restrict Query: If this option is checked, you can enable one of the following options
Read Only: Prevents the view from being used to add, delete, or change data in
the underlying table or tables.
Check Option: If this option is checked, it prohibits any changes to the underlying
table or tables that would produce rows that are not included in this view.
Force on create: If this option is checked, the view is created even if it has errors in its
definition. This option is useful if you want to create the view regardless of any errors,
and go back and correct the errors later. If this option is not checked, the view is not
created is its definition contains any errors.
Refresh properties for a materialized view (Materialized View Information tab):
Type: The type of refresh operation to be performed:
Complete Refresh: Executes the defining query of the materialized view, even if a
fast refresh is possible.
Fast Refresh: Uses the incremental refresh method, which performs the refresh
according to the changes that have occurred to the master tables. The changes for
conventional DML changes are stored in the materialized view log associated with
the master table.The changes for direct-path INSERT operations are stored in the
direct loader log.
Forced Refresh: Performs a fast refresh if one is possible; otherwise, performs a
complete refresh.
Method: Refresh method, which determines the type of materialized view:
Primary Key: Creates a primary key materialized view, which allows materialized
view master tables to be reorganized without affecting the eligibility of the
materialized view for fast refresh.
Row ID: Creates a rowid materialized view, which is useful if the materialized
view does not include all primary key columns of the master tables.
When: The type of refresh operation to be performed:
Automatic: Automatically performs a refresh operation, starting and continuing as

specified in the remaining fields.
On Commit: Performs a fast refresh whenever the database commits a transaction
that operates on a master table of the materialized view. This may increase the
Create/Edit View
time taken to complete the commit, because the database performs the refresh
operation as part of the commit process.
On Demand: Performs a refresh when one of the DBMS_MVIEW refresh

procedures is called.
At: Starting date and time for the first automatic refresh operation. Must be in the
future.
Then Every: Interval for subsequent automatic refresh operations. If you do not
specify an value, the refresh operation is performed only once at the time specified for
At.
DDL tab
If you are editing an existing view or if you have only partially created a view, this tab
shows a SQL statement that reflects the current definition of the view.
To save the SQL statement to a script file, click Save and specify the location and file
name.
FROM Clause tab
Specifies the tables and views that you can use in the FROM clause of the view
definition.
Available: Lists the tables and views that are available to be selected for use in the
FROM clause of the view definition.
Selected: Lists the tables and views that you can use in the FROM clause of the view
definition.
objects from available to selected, use the Add All (<<) icon; to move all objects from
selected to available, use the Remove All (<<) icon.
Alias: Alias for the table or view.
For the example for the DDL tab, select the EMP table.
SELECT Clause tab
Specifies objects that you can use in the SELECT clause of the view definition.
SELECT List: Lists the objects (typically, columns) that you can currently use in the
SELECT clause. To add an object, click the Add (+) icon; to delete an object, select it
and click the Delete (X) icon; to move an object up or down in the view definition,
select it and use the up-arrow and down-arrow keys.
After you add an object, to add another object, click the Add
(+) icon.
Note:
Expression: Column name or an expression. For expressions, you can type them, or
you can use the Expression Palette to add object names and function names.
Validate: Checks the validity of the Expression entry.
For the example for the DDL tab, select DEPTNO column and the MIN(emp.sal) and
MAX(emp.sal) functions.
Create/Edit View
WHERE Clause tab

Specifies the WHERE clause of the view definition.
WHERE: The text of the WHERE clause, without the WHERE keyword. You can type
the text completely; or you can type some of the text and use the Expression Palette to
add object names, function names, and operators.
Example (from the Creating a View tutorial exercise):
p.patron_id = t.patron_id
GROUP BY Clause tab

Specifies a clause to be used to group the selected rows based on the value of columns
for each row and return a single row of summary information for each group. The
GROUP BY clause groups rows but does not guarantee the order of the result set; to
order the groupings, use the ORDER BY clause.
Available: Lists the tables and views, and the columns in each, that are available to be
selected for use in the GROUP BY clause of the view definition.
Selected: Lists the tables and views, and the columns in each, that you can use in the
GROUP BY clause of the view definition.
objects from available to selected, use the Add All (<<) icon; to move all objects from
selected to available, use the Remove All (<<) icon.
HAVING Clause tab
Specifies an expression that must be satisfied for rows to be processed by the GROUP
BY clause. For example, HAVING MIN(salary) < 30000 causes the GROUP BY
clause to consider only rows where the minimum value of the relevant salary values is
less than 30000.
HAVING: You can type the complete expression text, or you can use the Expression
Palette to add object names, function names, and operators to the expression text.
ORDER BY Clause tab
Specifies one or more columns or column expressions whose values will be used to
sort the results returned by the view. Without an ORDER BY clause, no guarantee
exists that the same query executed more than once will retrieve rows in the same
order.
ORDER BY List: Lists the objects (typically, columns) that you can currently use in the
ORDER BY clause. To add an object, click the Add (+) icon; to delete an object, select it
and click the Delete (X) icon; to move an object up or down in the view definition,
select it and use the up-arrow and down-arrow keys.
After you add an object, to add another object, click the Add
(+) icon.
Note:
ORDER BY Expression Filter: For each column or column expression, you can type
the text completely into the Expression box; or you can type some of the text and use
the Expression Palette to add object names, function names, and operators.
Validate: Tests the validity of the syntax for the expression.
Configure File Type Associations
Order: ASC for ascending (expression values sorted in ascending order); DESC for
descending (expression values sorted in descending order).
Nulls Ordering: NULLS FIRST to have null expression values appear before non-null
values; NULLS LAST to have null expression values appear after non-null values.
("Before" and "after" positions are determined by the Order value.)
Entire SQL Query tab
Shows the entire SQL query for the view definition, and enables you to make changes
to the query.
Related Topics
Database Objects
3.23 Configure File Type Associations

This dialog box, which is displayed the first time you start Raptor, enables you to
associate certain file types with Raptor. If a file type is associated with Raptor, files
with that types extension will automatically be opened by Raptor when you
double-click the file name. Any previous association for that file type is replaced.
If you do not associate a file type with Raptor, any existing association for that file is
unchanged.
After you close this box, you can change the associations for these file types and many
others by clicking Tools and then Preferences, and selecting File Types (see File
Types).
3.24 Edit Value (Table Column Data)

This dialog box enables you to edit data in a cell in the table Data grid (that is, edit the
value of a single column within a row). You can change the data value and then click
OK.
3.25 Export Table Data

This dialog box is displayed when you right-click a table name and select Export and
then an export format. You can export some or all of the table data to a file or to the
system clipboard. To restrict the output to data in specified columns, use the Columns
tab. To restrict the output based on a WHERE clause condition, use the Where tab.
Format tab
Format: Determines the format of entries written in the specified output file: Insert for
SQL INSERT statements, XML for XML tags and data, SQL LOADER for a
SQL*Loader control file, or CSV for comma-separated values including a header row
for column identifiers.
Output: File writes the output to a file that you specify; Clipboard places the output on
the system clipboard, so that you can paste it into a file, a command line, or other
location appropriate for the format.
File: If the output is to a file, click Browse to select the directory or folder and to
specify the file name and extension. The file path is then placed in the File box.
Find/Replace Text
Standard file extensions are .sql for Insert format, .xml for XML format, .ctl for SQL
LOADER format, and .csv for CSV format.
Columns tab
You can specify whether the output should include data from all columns or just from
the checked columns.
Where tab
You can restrict the output by entering a valid WHERE clause for a query on the table,
without the WHERE keyword. For example, to restrict the exported data to rows
where a column named RATING contains a value greater than 5, specify: rating >
5
3.26 Externally Modified Files

This dialog box filters is displayed when an external application has modified a file
that you have open in Raptor. You are asked if you want to reload the externally
modified file.
If you click Yes, the externally modified file overwrites any changes that you might
have made in Raptor. If you click No, the externally modified file will be overwritten
by your version when you save the file in Raptor.
3.27 Filter Object Types

This dialog box filters (restricts) the types of objects to be displayed for the schema
associated with the selected user.
Available Object Types: Lists the types of objects that are available to be added to the
display.
Displayed Object Types: Lists the types of objects that are included in the display.
To add a type of object to the display, select it in Available Object Types and click the
Add (>) icon; to remove a type of object from the display, select it in Displayed Object
Types and click the Remove (<) icon. To move all types of objects from available to
displayed (or the reverse), use the Add All (>>) or Remove All (<<) icon.
3.28 Find/Replace Text

This dialog box specifies a text string to find, optionally a replacement text string, and
search options.
Text to Search For: Text string to search for.
Replace With: If you check this option, enter a text string to replace the text string that
is being searched for.
Options: Options to control the search behavior: Match Case makes the search case
sensitive; Search from Beginning starts the search at the beginning instead of at the
text cursor; Highlight All Occurrences highlights all occurrences of the search string
instead of just the first one; Wrap Around searches across line breaks; Whole Word
Only find the search string only if it is a complete word and not just part of a word;
Regular Expressions means that the search string is a regular expression; Selected
Text Only means to search only in the text block that you have selected.
Go to Line Number
Direction: Forward starts the search from the cursor in the direction of normal text
flow; Backward starts the search from the cursor in the opposite direction of normal
text flow.
3.29 Go to Line Number

Use this box to specify the line number to go to in the selected function or procedure.
After you enter the line number and click OK, that line is highlighted.
3.30 Go to Line Number: Error

This error box tells you that you entered an invalid line number in the Go to Line
Number box, probably because you entered a line number greater than that of the last
line in the function or procedure.
3.31 Load Preset Key Mappings

This dialog box is displayed when you click Load Preset when specifying accelerator
key preferences for Raptor. You can load a set of predefined key mappings for certain
systems and external editing applications. If you load any preset key mappings that
conflict with changes that you have made, your changes are overwritten
3.32 Open File

This is a standard box for selecting a file to open: use Location to navigate to
(double-clicking) the folder with the file to open, then click the file to select it.
3.33 Recent Files

This dialog box displays files recently opened in Raptor.
Files: A list of files opened in Raptor, with the most recent file first. The Show All
option determines whether the list includes only files opened implicitly or files opened
implicitly or explicitly.
Show All: If this option is checked, the list includes both explicitly and implicitly
opened files; if this option is not checked, the list includes only implicitly opened files.
Explicitly opened files are those that you opened directly; implicitly opened files are
those that Raptor opened to support your work (for example, while you were
debugging).
3.34 Run/Debug PL/SQL

Use this box to specify parameter values for running or debugging a PL/SQL function
or procedure. (If you specify a package, select a function or procedure in the package.)
Target: Name of the function or procedure to run or to run in debug mode. (You have a
choice only if you specified a package that has more than one subprogram.)
Parameters: List of each parameter for the specified target. The mode of each
parameter can be IN (the value is passed in), OUT (the value is returned, or IN/OUT
(the value is passed in, and the result of the function or procedures action is stored in
the parameter).
Create/Edit Breakpoint
PL/SQL Block: A block of PL/SQL code created by Raptor. You should change the
formal IN and IN/OUT parameter specifications in this block to actual values that you
want to use for running or debugging the function or procedure.
For example, to specify 10 as the value for an input parameter named in_rating,
change IN_RATING => IN_RATING to IN_RATING => 10.
When you click OK, Raptor runs the function or procedure.
If you are debugging a function or procedure, the debugging toolbar and one or more
windows for debug-related information are displayed, as explained in Running and
Debugging Functions and Procedures.
Related Topics
3.35 Create/Edit Breakpoint

Use this box to create or edit a breakpoint to use when debugging a PL/SQL function
or procedure.
Definition tab
Specify the definition of the breakpoint.
Breakpoint Type: Type of breakpoint, indicating when the breakpoint will occur.
Options include breaking when one of the following occurs: a specific line of code
(Source); exception class or other class; method, file, or watchpoint.
Breakpoint Details: Options depend on the breakpoint type.
Breakpoint Group Name: Breakpoint group in which to include this breakpoint.
Breakpoint groups can be edited, enabled, and disabled.
Conditions tab
Specify any conditions that apply to the breakpoint.
Condition: A SQL condition (WHERE clause without the WHERE keyword)
restricting when the breakpoint occurs. For example, to specify that the condition
should occur only when status_code is greater than 10, specify:
status_code > 10
Thread Options: You can specify whether the breakpoint occurs for all threads, or
only when the breakpoint is hit by threads that either do or do not have a specified
name.
Pass Count: The number of times the debugger should allow execution to pass over
the breakpoint before the breakpoint occurs.
Actions tab
Specify the actions to be taken when the breakpoint occurs. The options you specify
override any default values on the Debugger: Breakpoints: Default Actions pane of the
Raptor Preferences.
Halt Execution: Pauses execution when the breakpoint occurs.
Beep: Beeps when the breakpoint occurs.
Save/Save As
Log Breakpoint Occurrence: Sends a message to the log window when the breakpoint
occurs. You can also specify the following to be included in each display: a tag, and a
condition to be evaluated.
Enable/Disable a Group of Breakpoints: Enables or disables the specified breakpoint
group when this breakpoint occurs.
Related Topics
3.36 Save/Save As
This is a standard box for saving information to a file: use Location to navigate to
(double-clicking) the folder in which to save the file, then specify the file name
(including any extension) and, if necessary, the file type.
3.37 Save Style Settings

This dialog box is displayed when you click Save As in the Code Editor: Syntax Colors
pane when setting Raptor Preferences. You can save the specified color settings as a
named color scheme, which adds it to the drop-down list for Scheme in that pane.
3.38 SQL History List

Use this box, which is displayed by clicking the SQL History button in the SQL
Worksheet toolbar, to view SQL statements that you have executed and optionally to
select (check) them for operations. You can select all, one, or some of the statements. To
select all statements, check the box in the statement column heading. To show only
statements executed using a specific connection, select the connection from the
drop-down list, which initially contains All for all connections.
To save the selected statements to a SQL script file, click Save to File.
To append the selected statements to any statements currently on the SQL Worksheet,
click Append to Worksheet.
To have the selected statements replace any statements currently on the SQL
Worksheet, click Overwrite Worksheet.
Related Topics
3.39 SQL*Plus Location

Use this box to specify the location of the SQL*Plus executable on the system on which
you are running Raptor. The SQL*Plus executable is under the Oracle Home directory
or folder, and its specific location and file name depend on your operating system and
Oracle Database installation.
If there is no SQL*Plus executable on the system on which you are running Raptor,
you cannot invoke SQL*Plus from Raptor.
Related Topics
Using SQL*Plus
4
This topic discusses creating and managing database objects in your schema, plus
design considerations and indexing guidelines when developing applications with
Oracle Database. It contains the following topics:
Overview of Managing Objects
Managing Tables
Managing Indexes
Managing Views
Managing Sequences
Managing Synonyms
See Also:
Oracle Database SQL Reference for information about database

objects, object names, and data types.
4.1 Overview of Managing Objects

You need to create tables, indexes, and possibly other database objects in a schema
before you start developing your application. A schema is a collection of database
objects. A schema is owned by a database user and has the same name as that user,
such as the HR schema. Schema objects are logical structures created by users. Objects
can define areas of the database to hold data, such as tables or indexes, or can consist
just of a definition, such as a views or synonyms.
Database Objects: Usage Information discusses tables, indexes, views, sequences, and
synonyms. Other database (schema) objects include functions, packages, procedures,
and triggers. Functions, packages, and procedures are discussed in Subprograms and
Packages: Usage Information. Triggers are discussed in Triggers: Usage Information.
Some object types have many more management options than others, but most have a
number of similarities. Every object in the database belongs to just one schema and has
a unique name within that schema. Therefore, when you create an object, you must
ensure it is in the schema where you intend to store it. Generally, you place all of the
objects that belong to a single application in the same schema.
A database object name must abide by certain rules, including the rule that it must be
unique within its schema. For example, object names cannot be longer than 30 bytes
and must begin with a letter. If you attempt to create an object with a name that
violates any of these rules, then Oracle raises an error.
Database Objects: Usage Information 4-1
Managing Tables
To include lowercase characters, special characters, or spaces in an object name, you

must enclose the name in quotation marks (" ") when you type it in a Name field in
Raptor. Example: "My table"
The following topics describe how to view, create, and manage the various types of
objects in your database schemas:
Managing Tables
Managing Indexes
Managing Views
Managing Sequences
Managing Synonyms
4.2 Managing Tables

Tables are the basic unit of data storage in an Oracle database. They hold all
user-accessible data. A table is two-dimensional object comprised of columns and
rows. For example the employees table includes (vertical) columns called first_
name, last_name, and employee_id. Each (horizontal) row in the table contains a
value for employee name and Id number. The most common type of table in an Oracle
database is a relational table.
This topic contains the following topics:
Column Data Types
Column Default Values
Ensuring Data Integrity With Constraints
Column Constraints
Table-Level Constraints
See Also:
Oracle Database Administrator's Guide for information on managing

tables.
Oracle Database Concepts for conceptual information on tables
types.
Oracle Database SQL Reference for the syntax required to create and
alter tables.
4.2.1 Column Data Types

Data types are required elements that define the nature of the data to be stored in the
columns of a table. Data types might include a value to indicate the longest value that
can be placed in the column. When you create a table, you must specify a data type for
each of its columns. For a discussion of data types, see Data Types: Usage Information.
These data types define the domain of values that each column can contain or each
argument can have. For example, DATE columns cannot accept the value February
29 (except for a leap year) or the values 2 or SHOE. Each value subsequently placed in
a column assumes the column data type. For example, if you insert 17-JAN-2004 into
a date column, then Oracle treats the 17-JAN-2004 character string as a date value
after verifying that it translates to a valid date.
Managing Tables
Oracle Database SQL Reference for a complete list of

Oracles built-in data types.
See Also:
In most cases, you should only need columns of NUMBER, VARCHAR2, and DATE data
types when creating a definition of a table.
When defining numeric data, you can use the precision option to set the maximum
number of digits in the number, and the scale option to define how many of the digits
are to the right of the decimal point. For example, a field to hold monetary values
might be defined as NUMBER(12,2), providing ten digits for the primary unit of
currency (dollars, pounds, marks, and so on) and two digits for the secondary unit
(cents, pennies, pfennigs, and so on).
To define a VARCHAR2 field for character data, you must include the size value. Set the
size to the maximum number of bytes (or, optionally, characters) to be stored in the
column. A column to hold postal codes for different countries, for example, might be
restricted to 12 bytes by defining it as VARCHAR2(12).
DATE columns are automatically formatted by Oracle to include a date and time
component. Although both the date and time are stored in a date column, by default,
the date portion is automatically displayed for you, when retrieving date data.
However, Oracle Database enables you great flexibility in how you can display your
dates and times.
4.2.2 Column Default Values

Default values are values that are automatically stored into the column whenever a
new row is inserted without a value being provided for the column. When you define
a column with a default value, any new rows inserted into the table store the default
value unless the row contains an alternate value for the column. Assign default values
to columns that contain a typical value. For example, in the departments table, if
most departments are located at one site, then the default value for the location_id
column can be set to this value, such as 1700.
Default values can help avoid errors where there is a number, such as zero, that
applies to a column that has no entry. For example, a default value of zero can simplify
testing, by changing a test like this:
IF salary >= 0 AND salary < 50000
to the simpler form:
IF salary < 50000
Depending upon your business rules, you might use default values to represent zero
or FALSE, or leave the default values as NULL to signify an unknown value.
Default values can be defined using any literal, or almost any expression including
SYSDATE, which is a SQL function that returns the current date.
4.2.3 Ensuring Data Integrity With Constraints

You can define integrity constraints to enforce business rules on data in your tables.
Business rules specify conditions and relationships that must always be true, or must
always be false.
When an integrity constraint applies to a table, all data in the table must conform to
the corresponding rule. When you issue a SQL statement that inserts or modifies data
in the table, Oracle Database ensures that the new data satisfies the integrity
constraint, without the need to do any checking within your program.
Managing Tables
You can enforce rules by defining integrity constraints more reliably than by adding
logic to your application. Oracle Database can check that all the data in a table obeys
an integrity constraint faster than an application can.
Some constraints can be defined at the column level or at the table level. Column level
constraints are syntactically defined where the column to which the constraint applies
is defined. Table level constraints are syntactically defined at the end of the table
definition.
4.2.4 Column Constraints

Column constraints are optional elements that determine what values are valid in the
column.
The NOT NULL constraint on a column requires that the column must contain a value
whenever a row is inserted or updated. Unlike other constraints described in
"Table-Level Constraints" on page 4-4, which may be defined as part of the column
definition or part of the table definition, the NOT NULL constraint must be defined as
part of the column definition.
Use a NOT NULL constraint when the data is required for the integrity of the database.
For example, if all employees must belong to a specific department, then the column
that contains the department identifier should be defined with a NOT NULL constraint.
On the other hand, do not define a column as NOT NULL if the data may be unknown
or may not exist when rows are added or changed, for example, the second, optional
line in a mailing address.
A primary key constraint automatically adds a NOT NULL constraint to the column or
columns included in the primary key, in addition to enforcing uniqueness among the
values.
4.2.5 Table-Level Constraints

You can apply rules to preserve the integrity of your data. For example, in a table
containing employee data, the employee email column must be unique. Similarly, in
this table you cannot have two employees with the same employee Id.
Oracle Database enables you to apply data integrity rules as constraints on columns at
the table level. Any attempt to insert, update, or remove a row that violates a
constraint results in an error and the statement is rolled back. Likewise, any attempt to
apply a new constraint to a populated table also results in an error if any existing row
violates the new constraint.
The types of constraints you can apply at the table level are as follows:
Primary Key
Unique Key
Check Constraint
Foreign Key
Constraints can be created and, in most cases, modified with a number of different
status values. The options include enabled or disabled, which determine if the
constraint is checked when rows are added, modified, or removed; and deferred or
immediate, which cause constraint validation to occur at the end of a transaction or at
the end of a statement, respectively.
See Also:
constraints.
Oracle Database Concepts for more information on
Managing Tables
4.2.5.1 Primary Key

A primary key requires that a column (or combination of columns) be the unique
identifier of the row and ensures that no duplicate rows exist. A primary key column
cannot contain NULL values. Each table can have only one primary key.
Use the following guidelines when selecting a primary key:
Whenever practical, create a sequence number generator to generate unique

numeric values for your primary key values.
Choose a column whose data values are unique, because the purpose of a primary
key is to uniquely identify each row of the table.
Choose a column whose data values are never changed. A primary key value is
only used to identify a row in the table, and its data should never be used for any
other purpose. Therefore, primary key values should rarely or never be changed.
Choose a column that does not contain any nulls. A PRIMARY KEY constraint, by
definition, does not allow any row to contain a null in any column that is part of
the primary key.
Choose a column that is short and numeric. Short primary keys are easy to type.
Minimize your use of composite primary keys. A composite primary key
constraint applies to more than one column. Although composite primary keys are
allowed, they do not satisfy all of the other recommendations. For example,
composite primary key values are long and cannot be assigned by sequence
numbers.
4.2.5.2 Unique Key

A unique key requires that every value in a column be unique. That is, no two rows
can have duplicate values in a specified column or combination of columns.
Choose columns for unique keys carefully. The purpose of these constraints is different
from that of primary keys. Unique key constraints are appropriate for any column
where duplicate values are not allowed. Primary keys identify each row of the table
uniquely, and typically contain values that have no significance other than being
unique. In the employees table, the email column has a unique key constraint
because it is important that the emails for each employee are unique. Note that the
email column has a NOT NULL constraint.
Some examples of good unique keys include:
An employee social security number where the primary key might be the
employee number
A truck license plate number where the primary key might be the truck number
A customer phone number, consisting of the two columns area_code and
local_phone where the primary key might be the customer number
A department name and location where the primary key might be the department
number
4.2.5.3 Check Constraint

A check constraint requires that a column (or combination of columns) satisfy a
condition for every row in the table. A check constraint must be a boolean expression
that is evaluated using the column value about to be inserted or updated to the row.
Managing Indexes
Use CHECK constraints when you need to enforce integrity rules based on logical
expressions, such as comparisons. Never use CHECK constraints when any of the other
types of integrity constraints can provide the necessary checking.
Examples of CHECK constraints include the following:
A CHECK constraint on employee salaries so that no salary value is less than 0.

A CHECK constraint on department locations so that only the locations Boston,
New York, and Dallas are allowed.
A CHECK constraint on the salary and commissions columns to prevent the
commission from being larger than the salary.
4.2.5.4 Foreign Key

Whenever two tables contain one or more common columns, you can enforce the
relationship between the tables through a referential integrity constraint with a foreign
key. A foreign key requires that all column values in the child table exist in the parent
table. The table that includes the foreign key is called the dependent or child table. The
table that is referenced is called the parent table.
An example of a foreign key constraint is when the department column of the
employees table (child) must contain a department ID that exists in the parent
departments table.
Foreign keys can be comprised of multiple columns. Such a composite foreign key
must reference a composite primary or unique key of the exact same structure, with
the same number of columns and the same data types. Because composite primary and
unique keys are limited to 32 columns, a composite foreign key is also limited to 32
columns. You must use the same data type for corresponding columns in the parent
and child tables. The column names do not need to match.
4.3 Managing Indexes

Indexes are optional structures associated with tables. You can create them to improve
query performance. Just as the index in this book helps you to quickly locate specific
information, an Oracle Database index provides a quick access path to table data.
You can create indexes on one or more columns of a table. After an index is created, it
is automatically maintained and used by Oracle Database. Changes to a table's data or
structure, such as adding new rows, updating rows, or deleting rows, are
automatically incorporated into all relevant indexes with complete transparency to the
user.
Some indexes are created implicitly through constraints that are placed on a table. For
example, a column with the constraint that its values be unique causes Oracle
Database to create a unique key index.
Oracle Database automatically creates the indexes necessary to support data integrity
defined with constraints when you add or enable those constraints. For performance
purposes, you might want to add an index to the columns you define in a child table
when adding a foreign key constraint. Before you add additional indexes, you should
examine the performance of your database. You can then compare performance after
the new indexes are added.
After index creation, Oracle Database automatically synchronizes the index with any
subsequent inserts, updates, or deletes to the base table.
Indexes are generally of value to queries and to SQL statements that need to operate
on a single, existing row or a small number of existing rows. Too many indexes can
Managing Indexes
cause serious problems by increasing the processing overhead for statements that add,
modify, or delete rows. In some cases, a statement could use two or more indexes and
the optimizer picks just one of them. Unless other statements can take advantage of
the unused indexes, they are not providing any benefit. Therefore, you might find
yourself deleting indexes if you create too many.
Creating Indexes for Use with Constraints
Index Types
Guidelines for Creating Indexes
4.3.1 Creating Indexes for Use with Constraints

All enabled unique and primary keys require corresponding indexes, although in most
cases the indexes are created automatically. Note the following:
Constraints use existing indexes where possible, rather than creating new ones.
Unique and primary keys can use non-unique as well as unique indexes. They can
even use just the first few columns of non-unique indexes.
At most one unique or primary key can use each non-unique index.
The column orders in the index and the constraint do not need to match.
You should almost always index foreign keys; the database does not do this for you
automatically.
4.3.2 Index Types

Indexes can be categorized in a number of ways. The primary options are:
4.3.2.1 Normal
A standard, B-tree index contains an entry for each value in the index key along with
an address to the row where the value is stored. A B-tree index is the default and most
common type of index in an Oracle database.
4.3.2.2 Ascending and Descending

The default search through an index is from lowest to highest value, where character
data is sorted by ASCII values, numeric data from smallest to largest number, and date
from the earliest to the latest value. This default behavior is performed in indexes
created as ascending indexes. You can cause index searches to reverse the search order
by creating the related index with the descending option.
4.3.2.3 Column and Function-based

Typically, an index entry is based on the value or values found in the table's column or
columns. This is a column index. Alternatively, you can create a function-based index
in which the indexed value is derived from the table data. For example, to find
character data that can be in mixed case, you could use a function-based index to look
for the values as if they were all in uppercase characters.
4.3.2.4 Single Column and Concatenated

You can create an index on just one column, which is called a single column index, or
on multiple columns, which is called a concatenated index. Concatenated indexes are
Managing Indexes
useful when all of the columns are likely to be included in the WHERE clause of
frequently executed SQL statements.
For concatenated indexes, you should define the columns used in the index carefully
so that the column with the fewest duplicate values is named first, the column with
next fewest duplicate values is second, and so on. Columns with many duplicate
values or many rows with NULL values should not be included or should be the
last-named columns in the index definition.
4.3.3 Guidelines for Creating Indexes

You can create indexes on columns to speed up queries. Indexes provide faster access
to data for operations that return a small portion of a table's rows.
In general, you should create an index on a column in any of the following situations:
The column is queried frequently.
A referential integrity constraint exists on the column.
A UNIQUE key integrity constraint exists on the column.
You can create an index on any column; however, if the column is not used in any of
these situations, creating an index on the column does not increase performance and
the index takes up resources unnecessarily.
Although the database creates an index for you on a column with an integrity
constraint, explicitly creating an index on such a column is recommended.
4.3.3.1 Index the Correct Tables and Columns

Use the following guidelines for determining when to create an index:
Create an index if you frequently want to retrieve less than about 15% of the rows
in a large table. This threshold percentage varies greatly, however, according to the
relative speed of a table scan and how clustered the row data is about the index
key. The faster the table scan, the lower the percentage; the more clustered the row
data, the higher the percentage.
Index columns that are used for joins to improve join performance.
Primary and unique keys automatically have indexes, but you might want to
create an index on a foreign key. See "Foreign Key" on page 4-6 for more
information.
Small tables do not require indexes; if a query is taking too long, then the table
might have grown from small to large.
Some columns are strong candidates for indexing. Columns with one or more of the
following characteristics are good candidates for indexing:
Values are unique in the column, or there are few duplicates.
There is a wide range of values (good for regular indexes).
The column contains many nulls, but queries often select all rows having a value.
In this case, a comparison that matches all the non-null values, such as:
WHERE COL_X >= -9.99 *power(10,125)
is preferable to
WHERE COL_X IS NOT NULL
Managing Indexes
This is because the first uses an index on COL_X (assuming that COL_X is a
numeric column).
Columns with the following characteristics are less suitable for indexing:
There are many nulls in the column and you do not search on the non-null values.
The size of a single index entry cannot exceed roughly one-half (minus some
overhead) of the available space in the data block. Consult with the database
administrator for assistance in determining the space required by an index.
4.3.3.2 Limit the Number of Indexes for Each Table

The more indexes, the more overhead is incurred as the table is altered. When rows are
inserted or deleted, all indexes on the table must be updated. When a column is
updated, all indexes on the column must be updated.
You must weigh the performance benefit of indexes for queries against the
performance overhead of updates. For example, if a table is primarily read-only, you
might use more indexes; but, if a table is heavily updated, you might use fewer
indexes.
4.3.3.3 Choose the Order of Columns in Composite Indexes

Although you can specify columns in any order in the CREATE INDEX command, the
order of columns in the CREATE INDEX statement can affect query performance. In
general, you should put the column expected to be used most often first in the index.
You can create a composite index (using several columns), and the same index can be
used for queries that reference all of these columns, or just some of them.
For example, assume the columns of the vendor_parts table are as follows:
vendor_id
1010
1010
1012
1012
1012
1012
1220
1292
part_no
10-440
10-457
08-300
10-440
10-441
10-457
08-300
10-457
unit_cost
0.27
5.10
1.19
0.25
0.39
4.96
1.33
5.29
Assume that there are five vendors, and each vendor has about 1000 parts. Suppose
that the vendor_parts table is commonly queried by SQL statements such as the
following:
SELECT * FROM vendor_parts
WHERE part_no = 457 AND vendor_id = 1012;
To increase the performance of such queries, you might create a composite index
putting the most selective column first; that is, the column with the most values:
CREATE INDEX ind_vendor_id ON vendor_parts (part_no, vendor_id);
Composite indexes speed up queries that use the leading portion of the index. So in
this example, queries with WHERE clauses using only the part_no column also note a
performance gain. Because there are only five distinct values, placing a separate index
on vendor_id would serve no purpose.
Managing Views
4.3.3.4 Drop Indexes That Are No Longer Required

You might drop an index if:
It does not speed up queries. The table might be very small, or there might be
many rows in the table but very few index entries.
The queries in your applications do not use the index.
The index must be dropped before being rebuilt.
You cannot drop an index which is created through a constraint. You must drop the
constraint and then the index is dropped also.
If you drop a table, then all associated indexes are dropped.
To drop an index, the index must be contained in your schema or you must have the
DROP ANY INDEX system privilege.
4.4 Managing Views

Views are customized presentations of data in one or more tables or other views. You
can think of them as stored queries. Views do not actually contain data, but instead
derive their data from the tables upon which they are based. These tables are referred
to as the base tables of the view.
Like tables, views can be queried, updated, inserted into, and deleted from, with some
restrictions. All operations performed on a view actually affect the base tables of the
view. Views provide an additional level of security by restricting access to a
predetermined set of rows and columns of a table. They also hide data complexity and
store complex queries.
4.5 Managing Sequences

A sequence is a database object similar to a pseudocolumn that generates unique
sequential values. These values are often used for primary and unique keys. Using a
sequence generator to provide the value for a primary key in a table is an easy way to
guarantee that the key value is unique.
You can refer to sequence values in SQL statements with these pseudocolumns:
CURRVAL: Returns the current value of a sequence
NEXTVAL: Increments the sequence and returns the next value
You must qualify CURRVAL and NEXTVAL with the name of the sequence, such as
employees_seq.CURRVAL or employees_seq.NEXTVAL.
When you create a sequence, you can define its initial value and the increment
between its values. The first reference to NEXTVAL returns the initial value of the
sequence. Subsequent references to NEXTVAL increment the sequence value by the
defined increment and return the new value. Any reference to CURRVAL always
returns the current value of the sequence, which is the value returned by the last
reference to NEXTVAL.
Before you use CURRVAL for a sequence in your session, you must first initialize the
sequence with NEXTVAL.
Managing Synonyms
4.6 Managing Synonyms

A synonym is an alias for any schema object such as a table or view. Synonyms
provide an easy way to provide an alternative name for a database object and can be
used to simplify SQL statements for database users. For example, you can create a
synonym named emps as an alias for the employees table in the HR schema.
If a table in an application has changed, such as the personnel table has replaced the
employees table, you can use the employees synonym to refer to the personnel
table so that the change is transparent to the application code and the database users.
Because a synonym is simply an alias, it does not require any storage in the database
other than its definition.
You can create both public and private synonyms. A public synonym is owned by the
special user group named PUBLIC and every user in a database can access it. A private
synonym is in the schema of a specific user who has control over its availability to
others.
4-11
Managing Synonyms
5
The topic discusses the data types used with Oracle Database. It contains the following
topics:
Overview of Data Types on page 5-1
Storing Character Data on page 5-1
Storing Numeric Data on page 5-2
Storing Datetime Data on page 5-5

See Also:
Oracle Database SQL Reference for complete reference information

on the SQL data types
Oracle Database Concepts to learn about Oracle built-in data types
5.1 Overview of Data Types

A data type associates a fixed set of properties with the values that can be used in a
column of a table or in an argument of a procedure or function. These properties cause
Oracle Database to treat values of one data type differently from values of another
data type. For example, Oracle Database can use the addition operator on values of
NUMBER data type, but not with values of some other data types. The data types
supported by Oracle Database include characters, numbers, and dates and times
(known as datetime data types).
To view the data types contained in a database table, such as the employees table,
you can use Connections navigator or the SQL*Plus DESCRIBE. For information on the
SQL*Plus DESCRIBE command, see SQL*Plus DESCRIBE Command.
5.2 Storing Character Data

What are the Character Data Types?
Choosing Between the Character Data Types
5.2.1 What are the Character Data Types?

You can use the following SQL data types to store alphanumeric data:
VARCHAR2 and NVARCHAR2 data types store variable-length character literals.
Data Types: Usage Information 5-1
Storing Numeric Data
NCHAR and NVARCHAR2 data types store variable-length Unicode character data
only.
CHAR and NCHAR data types store fixed-length character literals.
See Also:
Oracle Database SQL Reference for information on data types

Oracle Database Globalization Support Guide for information on
globalization support
5.2.2 Choosing Between the Character Data Types

When deciding which data type to use for a column that will store alphanumeric data
in a table, consider the following points of distinction:
Space usage
To store data more efficiently, use the VARCHAR2 data type. The CHAR data type
blank-pads and stores trailing blanks up to a fixed column length for all column
values, whereas the VARCHAR2 data type does not add extra blanks.
Comparison semantics
Use the CHAR data type when you require ANSI compatibility in comparison
semantics (when trailing blanks are not important in string comparisons). Use the
VARCHAR2 when trailing blanks are important in string comparisons.
Future compatibility
The CHAR and VARCHAR2 data types are fully supported.
Oracle Database SQL Reference for more information on
comparison semantics for these data types
See Also:
5.3 Storing Numeric Data

What Are the Numeric Data Types?
Using NUMBER Data Types
Using Floating-Point Number Formats
5.3.1 What Are the Numeric Data Types?

The following SQL data types store numeric data:
NUMBER
BINARY_FLOAT
BINARY_DOUBLE
Use the NUMBER data type to store integers and real numbers in a fixed-point or
floating-point format. Numbers using this data type are guaranteed to be portable
among different Oracle Database platforms. For nearly all cases where you need to
store numeric data, you would use the NUMBER data type.
Oracle Database provides the numeric BINARY_FLOAT and BINARY_DOUBLE data
types exclusively for floating-point numbers. They support all of the basic
functionality provided by the NUMBER data type. However, while NUMBER uses
decimal precision, BINARY_FLOAT and BINARY_DOUBLE use binary precision. This

enables faster arithmetic calculations and usually reduces storage requirements.
See Also:
Oracle Database Concepts for information about the internal format

for the NUMBER data type
Oracle Database SQL Reference for more information about the
NUMBER, BINARY_FLOAT, and BINARY_DOUBLE data types
formats
5.3.2 Using NUMBER Data Types

The NUMBER data type stores zero as well as positive and negative fixed numbers with
absolute values from 1.0 x 10-130 to (but not including) 1.0 x 10126. If you specify an
arithmetic expression whose value has an absolute value greater than or equal to 1.0 x
10126, then Oracle returns an error. Each NUMBER value requires from 1 to 22 bytes.
When you specify a fixed-point number use the following form to specify the precision
and scale of the number:
NUMBER(precision, scale)
Precision and scale are defined as follows:
Precision is the total number of significant decimal digits, where the most
significant digit is the left-most nonzero digit, and the least significant digit is the
right-most known digit. For examples, see Table 51 on page 5-4.
Scale is the number of digits from the decimal point to the least significant digit.
The scale can range from -84 to 127. For examples, see Table 51 on page 5-4.
Positive scale is the number of significant digits to the right of the decimal
point to and including the least significant digit.
Negative scale is the number of significant digits to the left of the decimal
point, to but not including the least significant digit. For negative scale the
least significant digit is on the left side of the decimal point, because the actual
data is rounded to the specified number of places to the left of the decimal
point. For example, a specification of (10,-2) means to round to hundreds.
Scale can be greater than precision, most commonly when e notation is used. When
scale is greater than precision, the precision specifies the maximum number of
significant digits to the right of the decimal point. For example, a column defined as
NUMBER(4,5) requires a zero for the first digit after the decimal point and rounds all
values past the fifth digit after the decimal point.
It is good practice to specify the scale and precision of a fixed-point number column
for extra integrity checking on input. Specifying scale and precision does not force all
values to a fixed length. If a value exceeds the precision, then Oracle returns an error. If
a value exceeds the scale, then Oracle rounds it.
Specify an integer using the following form:
NUMBER(p)
This represents a fixed-point number with precision p and scale 0 and is equivalent to
NUMBER(p,0).
Specify a floating-point number using the following form:
NUMBER
The absence of precision and scale designators specifies the maximum range and
precision for an Oracle number.
Table 51 show how Oracle stores data using different values for precision and scale.
Table 51
Storage of Scale and Precision
Actual Data
Specified As
Stored As
123.89
NUMBER
123.89
123.89
NUMBER(3)
124
123.89
NUMBER(6,2)
123.89
123.89
NUMBER(6,1)
123.9
123.89
NUMBER(3)
exceeds precision
123.89
NUMBER(4,2)
exceeds precision
123.89
NUMBER(6,-2)
100
.01234
NUMBER(4,5)
.01234
.00012
NUMBER(4,5)
.00012
.000127
NUMBER(4,5)
.00013
.0000012
NUMBER(2,7)
.0000012
.00000123
NUMBER(2,7)
.0000012
1.2e-4
NUMBER(2,5)
0.00012
1.2e-5
NUMBER(2,5)
0.00001
5.3.3 Using Floating-Point Number Formats

The BINARY_FLOAT and BINARY_DOUBLE data types store floating-point data in the
32-bit IEEE 754 format and the double precision 64-bit IEEE 754 format respectively.
Compared to the Oracle NUMBER data type, arithmetic operations on floating-point
data are usually faster for BINARY_FLOAT and BINARY_DOUBLE. Also, high-precision
values require less space when stored as BINARY_FLOAT and BINARY_DOUBLE.
The floating-point number system is a common way of representing and manipulating
numeric values in computer systems. The value 4.32682E-21F is an example of a
BINARY_FLOAT data type.
Floating-point numbers can have a decimal point anywhere from the first to the last
digit or can have no decimal point at all. An exponent may optionally be used
following the number to increase the range (for example, 1.777 e-20). A scale value is
not applicable to floating-point numbers, because the number of digits that can appear
after the decimal point is not restricted.
Binary floating-point numbers differ from NUMBER in the way the values are stored
internally by Oracle Database. Values are stored using decimal precision for NUMBER.
All literals that are within the range and precision supported by NUMBER are stored
exactly as NUMBER. Literals are stored exactly because literals are expressed using
decimal precision (the digits 0 through 9). Binary floating-point numbers are stored
using binary precision (the digits 0 and 1). Such a storage scheme cannot represent all
values using decimal precision exactly. Frequently, the error that occurs when
converting a value from decimal to binary precision is undone when the value is
converted back from binary to decimal precision. The literal 0.1 is such an example.
Storing Datetime Data
5.3.3.1 BINARY_FLOAT
BINARY_FLOAT is a 32-bit, single-precision floating-point number data type. Each
BINARY_FLOAT value requires 5 bytes, including a length byte.
5.3.3.2 BINARY_DOUBLE
BINARY_DOUBLE is a 64-bit, double-precision floating-point number data type. Each
BINARY_DOUBLE value requires 9 bytes, including a length byte.
In a NUMBER column, floating point numbers have decimal precision. In a BINARY_
FLOAT or BINARY_DOUBLE column, floating-point numbers have binary precision.
The binary floating-point numbers support the special values infinity and NaN (not a
number).
You can specify floating-point numbers within the limits listed in Table 52 on
page 5-5.
Table 52
Floating Point Number Limits
Value
Binary-Float
Binary-Double
Maximum positive finite value
3.40282E+38F
1.79769313486231E+308
Minimum positive finite value
1.17549E-38F
2.22507485850720E-308
5.4 Storing Datetime Data

Using DATE and TIMESTAMP Data Types
Manipulating the DATE and TIME Formats
5.4.1 Using DATE and TIMESTAMP Data Types

Oracle Database supports the following datetime data types:
DATE
TIMESTAMP
TIMESTAMP WITH TIME ZONE
TIMESTAMP WITH LOCAL TIME ZONE

See Also:
Oracle Database SQL Reference for information on DATE,

TIMESTAMP, TIMESTAMP WITH TIME ZONE, and TIMESTAMP
WITH LOCAL TIME ZONE data types
5.4.1.1 Using the DATE Data Type

Use the DATE data type to store point-in-time values (dates and times) in a table. An
application that specifies the time for a job might use the DATE data type.
The DATE data type stores the century, year, month, day, hours, minutes, and seconds.
The valid date range is from January 1, 4712 BC to December 31, 9999 AD.
5.4.1.2 Using the TIMESTAMP Data Type

Use the TIMESTAMP data type to store values that are precise to fractional seconds. An
application that must decide which of two events occurred first might use
TIMESTAMP.
5.4.1.3 Using the TIMESTAMP WITH TIME ZONE Data Type

Because TIMESTAMP WITH TIME ZONE can also store time zone information, it is
particularly suited for recording date information that must be gathered or
coordinated across geographic regions.
5.4.1.4 Using the TIMESTAMP WITH LOCAL TIME ZONE Data Type
Use TIMESTAMP WITH LOCAL TIME ZONE when the time zone is not significant. For
example, you might use it in an application that schedules teleconferences, where
participants each see the start and end times for their own time zone.
The TIMESTAMP WITH LOCAL TIME ZONE type is appropriate for two-tier
applications in which you want to display dates and times that use the time zone of
the client system. It is generally inappropriate in three-tier applications because data
displayed in a Web browser is formatted according to the time zone of the Web server,
not the time zone of the browser. The Web server is the database client, so its local time
is used.
5.4.1.5 Representing the Difference Between Datetime Values

Use the INTERVAL DAY TO SECOND data type to represent the precise difference
between two datetime values. For example, you might use this value to set a reminder
for a time 36 hours in the future or to record the time between the start and end of a
race. To represent long spans of time with high precision, you can use a large value for
the days portion.
Use the INTERVAL YEAR TO MONTH data type to represent the difference between
two datetime values, where the only significant portions are the year and the month.
For example, you might use this value to set a reminder for a date 18 months in the
future, or check whether 6 months have elapsed since a particular date.
Oracle Database stores dates in its own internal format which is fixed-length fields of
seven bytes each, corresponding to century, year, month, day, hour, minute, and
second.
5.4.2 Manipulating the DATE and TIME Formats

For input and output of dates, the standard Oracle Database default date format is
DD-MON-RR. The RR datetime format element enables you store 20th century dates in
the 21st century by specifying only the last two digits of the year.
Time is stored in a 24-hour format as HH24:MI:SS. By default, the time in a DATE
column is 12:00:00 A.M. (midnight) if no time portion is entered or if the DATE is
truncated. In a time-only entry, the date portion defaults to the first day of the current
month.
You can change the current default date or time format for a specific date or timestamp
with the use the TO_DATE or TO_TIMESTAMP function with a format mask, such as:
TO_DATE('27-OCT-98', 'DD-MON-RR')
TO_DATE('15-NOV-05 10:56 A.M.','DD-MON-YY HH:MI A.M.')
TO_TIMESTAMP ('10-Sep-05 14:10:10.123000',
'DD-Mon-RR HH24:MI:SS.FF')
Oracle Database provides various functions for calculating and converting datetime
data. For examples in SQL statements, see Using Date Functions.
Be careful when using a date format such as DD-MON-YY. The YY indicates the year in
the current century. For example, 31-DEC-92 is December 31, 2092, not 1992 as
you might expect. If you want to indicate years in any century other than the current
one, use a format mask such as the default RR.
You can use the following techniques to change the default date format on a more
global level:
To change on an instance-wide basis, use the NLS_DATE_FORMAT parameter.
To change during a session, use the ALTER SESSION statement.
For more information on these techniques, see Working in a Global Environment.

See Also:
Oracle Database SQL Reference for more information about date and
time formats
Oracle Database Concepts for information about Julian dates. Oracle
Database Julian dates might not be compatible with Julian dates
generated by other date algorithms.
6
This topic discusses how to use SQL with Oracle Database. It includes the following
topics:
Overview of SQL
Retrieving Data With Queries
Manipulating Data With SQL Statements
Transaction Control Statements
Using Pseudocolumns, Sequences, and SQL Functions
Using SQL Data Definition Language Statements

See Also:
Oracle Database SQL Reference for detailed information about SQL

statements and other parts of SQL, such as operators, functions,
and format models.
Oracle Database Concepts for conceptual information on SQL.
SQL*Plus User's Guide and Reference for information about
SQL*Plus, Oracle's version of SQL.
Oracle Database Sample Schemas for information on the HR sample
schema that is used for examples.
6.1 Overview of SQL

Structured Query Language (SQL) is a database access, nonprocedural language.
Users issue SQL statements or commands to perform various tasks, such as retrieving
data, and the SQL language compiler automatically handles how to navigate the
database and perform the desired task. All database operations are performed using
SQL.
This topic includes the following topics:
Features of SQL
Types of SQL Statements
6.1.1 Features of SQL

With SQL statements you can perform the following:
Query, insert, and update data in tables
SQL: Usage Information 6-1
Format, perform calculations on, store, and print from query results
Examine table and object definitions
Develop and run batch scripts
Perform database administration
6.1.2 Types of SQL Statements

All operations performed on the information in an Oracle database are run using SQL
statements. A statement consists partially of SQL reserved words, which have special
meaning in SQL and cannot be used for any other purpose. For example, SELECT and
UPDATE are reserved words and cannot be used as table names.
A SQL statement is an instruction. The statement must be the equivalent of a complete
SQL sentence, as in:
SELECT last_name, department_id FROM employees;
Oracle SQL statements are divided into several categories:
Data Manipulation Language (DML) Statements

These statements query, insert, update, delete data in tables.

These statements commit or rollback the processing of transactions. A group of
changes that you make is referred to as a transaction.
Data Definition Language (DDL) Statements

These create, alter, and drop database objects.
6.2 Retrieving Data With Queries

You can retrieve data from rows stored one or more database tables or views with a
query using the SQL SELECT statement. The SELECT statement retrieves the all of or
part of the column data from rows depending on the conditions that you specify in
WHERE clauses. The group of columns that are selected from a table is referred to as the
SELECT list.
Displaying Data Using the SELECT Statement
Using Character Literals in SQL Statements
Using a Column Alias to Change Headings When Selecting Data
Restricting Data Using the WHERE Clause
Sorting Data Using the ORDER BY Clause
Displaying Data From Multiple Tables
6.2.1 Displaying Data Using the SELECT Statement

With the SQL SELECT statement, you can query and display data of tables in a
database.
Example 61 shows how to use SELECT to retrieve data from the employees table. In
this example, the data for all columns in a row (record) of the employees table is
retrieved with the use of the wildcard (*) notation. Note the use of comments to
document the SQL statements. The comments (or remarks) in this example begin with
--, but you could also use rem or REM.
Example 61 Using SELECT to Retrieve Data
-- the following uses the wildcard * to retrieve all the columns of data in
-- all rows of the employees table
SELECT * FROM employees;
Example 62 shows how to use SELECT to retrieve the data for specific columns of the
employees table. In this example, you explicitly enter the column names in the
SELECT statement.
Example 62 Using SELECT to Retrieve Data From Specific Columns
-- the following retrieves the data in columns employee_id, last_name, first_name
SELECT employee_id, last_name, first_name FROM employees;
See Also:
Oracle Database SQL Reference for detailed information on the SQL

SELECT statement.
6.2.2 Using Character Literals in SQL Statements

Many SQL statements, functions, expressions, and conditions require you to specify
character literal values. You can specify character literals with the following notations:
Character literals with the 'text' notation, as in the literals 'users01.dbf'

and 'Muthu''s computer'.
National character literals with the N'text' or n'text' notation, where N or n
specifies the literal using the national character set. For example, N'rsum' is a
National character literal.
For information on unicode literals, see Unicode String Literals.
6.2.2.1 Quoting Character Literals

By default you must quote character literals in single-quotes, as in 'Hello'. This
technique can sometimes be inconvenient if the text itself contains single quotes. In
such cases, you can also use the Q-quote mechanism, which enables you to specify q
or Q followed by a single quote and then another character to be used as the quote
delimiter. For example, the literal q'#it's the "final" deadline#' uses the
pound sign (#) as a quote delimiter for the string it's the "final" deadline.
The Q-quote delimiter can be any single- or multibyte character except space, tab, and
return. If the opening quote delimiter is a [, {, <, or ( character, then the closing quote
delimiter must be the corresponding ], }, >, or ) character. In all other cases, the
opening and closing delimiter must be the identical character.
The following character literals use the alternative quoting mechanism:
q'(name LIKE '%DBMS_%%')'
q'<'Data,' he said, 'Make it so.'>'
q'"name like '['"'
nq'1234'
See Also:
Oracle Database Globalization Support Guide to learn about national

character sets
Oracle Database SQL Reference to learn about character literals
6.2.3 Using a Column Alias to Change Headings When Selecting Data

When displaying the result of a query, SQL normally uses the name of the selected
column as the column heading. You can change a column heading by using a column
alias to make the heading more descriptive and easier to understand.
You can specify the alias after the column name in the SELECT list using a space as a
separator. If the alias contains spaces or special characters (such as # or $), or if it is
case-sensitive, enclose the alias in double quotation marks (" ").
Example 63 shows the use of a column alias to provide more description for each
heading of the columns selected in a query.
Example 63 Using a Column Alias
-- the following retrieves the data in columns employee_id, last_name, first_name
-- and provides column aliases for more descriptive headings of the columns
SELECT employee_id "Employee Id number", last_name "Employee last name",
first_name "Employee first name" FROM employees;
6.2.4 Restricting Data Using the WHERE Clause

The WHERE clause uses comparison operators to identify specific rows in a table. When
used with the SELECT statement, you can selectively retrieve rows from a table rather
than retrieving all rows of a table.
Comparison operators include those listed in Table 61.
Table 61
Comparison Operators
Operator
Definition
=, !=, <>
test for equal, not equal, not equal
>, >=, <, <=
test greater than, greater than or equal to, less than, less than or
equal to
BETWEEN ... AND ...
check for range between and including two values
LIKE
search for a match in string, using the wildcard symbols % (zero

or multiple characters) or _ (one character)
IN ( )
test for a match in a specified list of values
IS NULL, IS NOT NULL
check whether is null (no value), is not null
Example 64 shows how to use SELECT with a WHERE clause and several comparison
operators to retrieve specific rows of data from the employees table.
Example 64 Using SELECT With a WHERE Clause
-- the following retrieves data where the manager_id equals 122
SELECT * FROM employees WHERE manager_id = 122;
-- this retrieves data where the manager_id equals 122 and job_id is ST_CLERK
SELECT * FROM employees WHERE manager_id = 122 AND job_id = 'ST_CLERK';
-- this retrieves employees with managers with Ids between 122 and 125 inclusive
SELECT * FROM employees WHERE manager_id BETWEEN 122 AND 125;
-- this uses the wildcard % to retrieve employee data
-- where the last name contains mar somewhere in the name
SELECT employee_id, last_name FROM employees WHERE last_name LIKE '%mar%';
-- this retrieves employees where the last name starts with Mar
SELECT employee_id, last_name FROM employees WHERE last_name LIKE 'Mar%';
-- this retrieves employees where the commission percentage is not null
SELECT employee_id, last_name FROM employees WHERE commission_pct IS NOT NULL;
-- the following retrieves data where the employee_id equals 125, 130, or 135
SELECT employee_id, last_name, first_name FROM employees
WHERE employee_id IN (125, 130, 135);
See Also:
Oracle Database SQL Reference for detailed information on using

the WHERE clause.
6.2.5 Sorting Data Using the ORDER BY Clause

You can use SELECT with the ORDER BY clause to retrieve and display rows from a
table ordered (sorted) by a specified column in the table. The specified column in the
ORDER BY clause does not have to be in the select-list of columns that you want to
display.
You can specify the sort order ASC for ascending or DESC for descending. The default
sort order is ascending, which means:
Numeric values are displayed with the lowest values first, such as 1 to 999.
Character values are displayed in alphabetical order, such as A first and Z last.
Date values are displayed with the earliest value first, such as 01-JUN-93 before
01-JUN-95.
Null (empty) values are displayed last for ascending sequences and first for
descending sequences.
Example 65 shows how to use SELECT with the ORDER BY clause to retrieve and
display rows from the employees table ordered (sorted) by specified columns.
Example 65 Using SELECT With ORDER BY
-- the following retrieves rows with manager_id = 122 ordered by employee_id
-- the order is the default ascending order, lowest employee_id displays first
SELECT * FROM employees WHERE manager_id = 122 ORDER BY employee_id;
-- the following retrieves rows ordered by manager_id
-- the order is specified as descending, highest manager_id displays first
SELECT employee_id, last_name, first_name, manager_id FROM employees
ORDER BY manager_id DESC;
See Example 620 on page 6-14 for the use of ORDER BY with the GROUP BY clause.
See Also:
Oracle Database SQL Reference for detailed information on using

ORDER BY with SELECT.
6.2.6 Displaying Data From Multiple Tables

You can use SELECT to display data from the multiple tables. This process is referred
to as joining the tables. In a join, multiple tables share a similar column.
When you retrieve data from multiple tables, you can explicitly identify which table a
column belongs to. This is important when tables contain columns with the same
name. You can use the complete table name to explicitly identify a column, such as
employees.employee_id, or a table alias. Note the use of the table aliases (d, e, and
l) to explicitly identify the columns by table in the SQL statement. The alias is defined
in the FROM clause of the SQL statement. A table alias is used to simply and reduce the
size of the SQL code.
Example 66 is an example of querying data from joined tables using ANSI syntax.
The first SELECT joins two tables and the second SELECT joins three tables.
Example 66 Selecting Data From Multiple Tables With the ANSI Join Syntax
-- the following SELECT statements retrieve data from two tables
-- that have a corresponding column (department_id)
-- this join uses ANSI syntax, note the use of JOIN and ON
SELECT e.employee_id, e.last_name, e.first_name, e.department_id,
d.department_name FROM employees e
JOIN departments d ON e.department_id = d.department_id;
-- the following SELECT retrieves data from three tables
-- two tables have the corresponding column department_id and
-- two tables have the corresponding column location_id
d.department_name, d.location_id, l.country_id FROM employees e
JOIN departments d ON e.department_id = d.department_id
JOIN locations l ON d.location_id = l.location_id;
In Example 67 the joins use the Oracle-proprietary syntax. There is no performance

difference between the ANSI and Oracle syntax.
Example 67 Using SELECT to Display Data From Multiple Tables
-- the following SELECT statements retrieve data from two tables
-- that have a corresponding column (department_id)
-- note that the employees table has been aliased to e and departments to d
d.department_name FROM employees e, departments d
WHERE e.department_id = d.department_id;
-- the following SELECT retrieves data from three tables
-- two tables have the corresponding column department_id and
-- two tables have the corresponding column location_id
SELECT e.employee_id, e.department_id, d.department_name, d.location_id,
l.country_id FROM employees e, departments d, locations l
WHERE e.department_id = d.department_id AND d.location_id = l.location_id;
Manipulating Data With SQL Statements
See Also:
"Joins" in Oracle Database SQL Reference for information on using

SELECT with multiple tables.
6.3 Manipulating Data With SQL Statements

Data manipulation language (DML) statements query or manipulate data in existing
schema objects. They enable you to:
Add new rows of data into a table or view (INSERT)
Change column values in existing rows of a table or view (UPDATE)
Remove rows from tables or views (DELETE)
DML statements are the most frequently used SQL statements.
Adding Data With the INSERT Statement
Updating Data With the UPDATE Statement
Deleting Data With the DELETE Statement
6.3.1 Adding Data With the INSERT Statement

You can use the SQL INSERT statement to add a row of data to a table. The data
inserted must be valid for the data type and size of each column of the table.
Example 68 shows how to use INSERT to add a row to the employees table. In the
first INSERT statement, values are inserted into all columns in a row of the table.
When you insert data into the columns, you must provide data values that are valid
for the data type and size of the column.
In the second INSERT statement, values are inserted only into the specified columns of
the table and the remaining columns are set to NULL. If the those remaining columns
had been specified with a NOT NULL constraint for the table, an error would have been
raised. For information on constraints, see "Managing Tables" and Column
Constraints.
Example 68 Using the INSERT Statement
-- the following inserts data for all the columns in a row
INSERT INTO employees VALUES
(300, 'Enrique', 'Belden', 'enrique.belden', '555.111.2222',
'01-AUG-05', 'AC_MGR', 9000, .1, 101, 110);
-- the following inserts data into the columns specified by name
-- NULLs are inserted in those columns not explicitly named
INSERT INTO employees (employee_id, last_name, email, hire_date, job_id, salary)
VALUES (301, 'Doe', 'john.doe', '31-AUG-05', 'SH_CLERK', 2400);
-- the following shows the rows were inserted beginning with 300
SELECT employee_id, last_name FROM employees WHERE employee_id >= 300;
See Also:
Oracle Database SQL Reference for information on the INSERT

statement.
6.3.2 Updating Data With the UPDATE Statement

You can use the SQL UPDATE statement to update data in a row of a table. The
updated data must be valid for the data type and size of each column of the table.
Example 69 shows how to use UPDATE to update data in the employees table. Note
the use of the use of multiplication operator * to calculate a new salary. For
information on arithmetic operators, See "Using Arithmetic Operators" on page 6-12.
Example 69 Using the UPDATE Statement
SELECT salary FROM employees WHERE employee_id = 301;
-- update the salary for employee 301, multiply the salary by 105%
UPDATE employees SET salary = salary * 1.05 WHERE employee_id = 301;
-- the following should show a change in salary
SELECT salary FROM employees WHERE employee_id = 301;
See Also:
Oracle Database SQL Reference for information on the UPDATE

statement.
6.3.3 Deleting Data With the DELETE Statement

With the SQL DELETE statement you can delete all or specific rows in a table.
When you delete all the rows in a table, the empty table still exists. If you want to
remove the entire table from the database, use the SQL DROP statement. See "Dropping
a Table With SQL" on page 6-17.
Example 610 shows how to use DELETE to delete selected rows in the employees
table. Note the use of the WHERE clause. Without that clause, all the rows would be
deleted.
Example 610
Using the DELETE Statement
DELETE FROM employees WHERE employee_id = 300 OR employee_id = 301;

-- the following query should not find any records
SELECT * FROM employees WHERE employee_id = 300 OR employee_id = 301;
If you accidentally delete rows, you can restore the rows with the ROLLBACK
statement. See "Rolling Back a Transaction" on page 6-9.
See Also:
Oracle Database SQL Reference for information on the DELETE

statement.
6.4 Transaction Control Statements

Transaction control statements manage the changes made by DML statements and
group DML statements into transactions. They enable you to:
Make a transaction's changes permanent (COMMIT)

Undo the changes in a transaction, either since the transaction started or since a
savepoint (ROLLBACK)
Committing Transaction Changes
Rolling Back a Transaction
6.4.1 Committing Transaction Changes

The SQL COMMIT statement saves any changes you have made to the database. When
a COMMIT has been executed, all the recent changes since the last COMMIT, or since you
logged on as the current user, are saved.
Example 611 shows how to use COMMIT to commit (save) changes to the employees
table in the database.
Example 611
Using the COMMIT Statement
-- add a row and then update the data

INSERT INTO employees (employee_id, last_name, email, hire_date, job_id, salary)
VALUES (301, 'Doe', 'john.doe', '31-AUG-05', 'SH_CLERK', 2400);
UPDATE employees SET salary = salary*1.10 WHERE employee_id = 301;
-- commit (save) the INSERT and UPDATE changes in the database
COMMIT;
See Also:
Oracle Database SQL Reference for information on the COMMIT

statement.
6.4.2 Rolling Back a Transaction

You can use the SQL ROLLBACK statement to rollback (undo) any changes you made to
the database before a COMMIT has been executed.
Example 612 shows how to use ROLLBACK to rollback the deletions made to the
employees table. Note that the ROLLBACK was issued before a COMMIT was executed.
Example 612
Using the ROLLBACK Statement
-- delete a row (record)

DELETE FROM employees WHERE last_name = 'Doe';
-- rollback the delete statement because the previous DELETE was incorrect
ROLLBACK;
-- the following is valid
SELECT * FROM employees WHERE last_name = 'Doe';
See Also:
Oracle Database SQL Reference for information on the ROLLBACK

statement.
6.5 Using Pseudocolumns, Sequences, and SQL Functions

With SQL built-in functions you can manipulate character, numeric, and date data in
SQL statements. You can also perform operations on a collection of data with the
aggregate functions.
Pseudocolumns are built-in values that provide specific information with a query and
are similar to functions without arguments. However, functions without arguments
typically return the same value for every row in the result set, whereas
pseudocolumns typically return a different value for each row.
Using Pseudocolumns With SQL
Using Sequences
Using Character Functions
Using Arithmetic Operators
Using Numeric Functions
Using Date Functions
Using Aggregate Functions

See Also:
Oracle Database SQL Reference for detailed information on SQL

functions.
6.5.1 Using Pseudocolumns With SQL

A pseudocolumns is similar to a table column, but is not actually stored in a table. A
pseudocolumn returns a value so it is similar to a function without argument. Oracle
Database provides several pseudocolumns, such as the ROWNUM, SYSDATE, and USER.
The ROWNUM pseudocolumn returns a number indicating the order in which Oracle
selects the row in a query. SYSDATE returns the current date and time set for the
operating system on which the database resides. USER returns the name of the user
name that is currently logged in.
Example 613 show the use of the ROWNUM, SYSDATE, and USER pseudocolumns. Note
the use of the table DUAL, which is automatically created by Oracle Database for use as
a dummy table in SQL statements.
Example 613
Using Pseudocolumns
-- the following statement displays the SYSDATE, which is the current system date
-- NOW is a column alias for display purposes
-- DUAL is a dummy table with one row simply used to complete the SELECT statement
SELECT SYSDATE "NOW" FROM DUAL;
-- display the name of the current user, the user name should be HR
SELECT USER FROM DUAL;
-- using ROWNUM < 10 limits the number of rows returned to less than 10
SELECT employee_id, hire_date, SYSDATE FROM employees WHERE ROWNUM < 10;
See Example 618 on page 6-14 for another example of the use of SYSDATE.
6.5.2 Using Sequences

A sequence is a database object similar to a pseudocolumn that generates unique
sequential values, often used for primary and unique keys. You can refer to sequence
values in SQL statements with the CURRVAL and NEXTVAL pseudocolumns.
To generate a sequence number, you call the sequence using the CURRVAL or NEXTVAL
keywords. You must qualify CURRVAL and NEXTVAL with the name of the sequence,
such as employees_seq.CURRVAL or employees_seq.NEXTVAL. Before you use
CURRVAL for a sequence in your session, you must first initialize the sequence with
NEXTVAL.
Example 614 shows an example of the use of the employees_seq sequence with the
employee_id of the employees table. The employees_seq sequence is part of the
HR schema and had been created for use with the employees table. When a sequence
is intended to be used with a specific table, it is a good practice to include the name of
the table in the sequence name.
Example 614
Using Sequences
-- first initialize the employees_seq sequence with NEXTVAL

SELECT employees_seq.NEXTVAL FROM DUAL;
-- after initializing the sequence, use CURRVAL as the next value in the sequence
(employees_seq.CURRVAL, 'Belinda', 'Vernal', 'belinda.vernal', '555.111.2342',
'15-AUG-05', 'ST_CLERK', 6000, NULL, 124, 50);
-- query the employees table to check the current value of the sequence
-- which was inserted used as employee_id in the previous INSERT statement
SELECT employee_id, last_name FROM employees WHERE last_name = 'Vernal';
6.5.3 Using Character Functions

Oracle Database provides a set of character functions that you can use in your SQL
statements to customize the character values. With character functions, you can
perform operations that upper case, lower case, trim blanks from, and concatenate
character data.
Example 615 shows how to use character functions on character data.
Example 615
Using Character Functions
-- you can use the UPPER function to display uppercase data, LOWER for lowercase
SELECT employee_id, UPPER(last_name), LOWER(first_name) FROM employees;
-- you can use CONCAT function to concatenate character data
SELECT CONCAT('Last name: ', last_name) FROM employees;
-- you can use RTRIM and LTRIM to remove spaces from the beginning or end of
-- character data. Note the use of concatenation operator ||
SELECT employee_id, RTRIM(first_name) || ' ' || LTRIM(last_name) FROM employees;
-- you can TRIM to remove spaces from both the beginning and end
SELECT employee_id, TRIM(last_name) || ', ' || TRIM(first_name) FROM employees;
-- you can format the system date (SYSDATE) as a character string
-- with various format masks and then display
-- the following displays September 21 2005
SELECT TO_CHAR(SYSDATE, 'fmMonth DD YYYY') "Today" FROM DUAL;

-- the following displays 21-SEP-2005 AD
SELECT TO_CHAR(SYSDATE, 'DD-MON-YYYY AD') "Today" FROM DUAL;
6.5.4 Using Arithmetic Operators

You can use arithmetic operators to create expressions for calculations on data in
tables. The arithmetic operators include:
+ for addition
- for subtraction
* for multiplication
/ for divide
In an arithmetic expression, multiplication and division are evaluated first, then

addition and subtraction. When operators have equal precedence, the expression is
evaluated left to right. It is best to include parentheses to explicitly determine the order
of operators and provide clarity in the expression.
Example 616 shows the use of arithmetic operators in expressions with the data in the
employees table. Note the use of a column alias to provide a more useful heading for
the displayed output.
Example 616
Using Arithmetic Operators
-- in the following query the commission is displayed as a percentate instead

-- of the decimal that is stored in the database
SELECT employee_id, (commission_pct * 100) "Commission %" FROM employees;
-- in the following query, the proposed new annual salary is calculated
-- for employees who report to the manager with Id 145
SELECT employee_id, ((salary + 100) * 12) "Proposed new annual salary"
FROM employees WHERE manager_id = 145;
6.5.5 Using Numeric Functions

Oracle Database provides a set of numeric functions that you can use in your SQL
statements to manipulate the numeric values. With numeric functions, you can
perform operations that upper case, lower case, trim blanks from, and concatenate
character data.
Example 617 shows how to use numeric functions on numeric data in the
employees table.
Example 617
Using Numeric Functions
-- you can use the ROUND function to round off numeric data, in this case to
-- two decimal places
SELECT employee_id, ROUND(salary/30, 2) "Salary per day" FROM employees;
-- you can use the TRUNC function to truncate numeric data, in this case to
-- 0 decimal places; 0 is the default so TRUNC(salary/30) would be same
SELECT employee_id, TRUNC(salary/30, 0) "Salary per day" FROM employees;
6.5.6 Using Date Functions

Oracle Database provides various functions for calculating and converting datetime
data.
See Also:
functions
Oracle Database SQL Reference for details about the date
Performing Date Arithmetic

Oracle Database provides a number of features to help with date arithmetic, so that
you do not need to perform your own calculations on the number of seconds in a day,
the number of days in each month, and so on. Some useful features include the
following:
ADD_MONTHS function, which returns the date plus the specified number of
months.
MONTHS_BETWEEN function, which returns the number of months between two
dates.
SYSDATE function, which returns the current date and time set for the operating
system on which the database resides.
SYSTIMESTAMP function, which returns the system date, including fractional
seconds and time zone, of the system on which the database resides.
TRUNC function, which when applied to a DATE value, trims off the time portion
so that it represents the very beginning of the day (the stroke of midnight). By
truncating two DATE values and comparing them, you can determine whether
they refer to the same day. You can also use TRUNC along with a GROUP BY clause
to produce daily totals.
Arithmetic operators such as + and -. For example, SYSDATE-7 refers to 7 days
before the current system date.
INTERVAL data types, which enable you to represent constants when performing
date arithmetic rather than performing your own calculations. For example, you
can add or subtract INTERVAL constants from DATE values or subtract two DATE
values and compare the result to an INTERVAL.
Comparison operators such as >, <, =, and BETWEEN.
Converting Between Datetime Types

Oracle Database provides several useful functions that enable you to convert to a from
datetime data types. Some useful functions include:
EXTRACT, which extracts and returns the value of a specified datetime field from a
datetime or interval value expression
NUMTODSINTERVAL, which converts a NUMBER or expression that can be implicitly
converted to a NUMBER value to an INTERVAL DAY TO SECOND literal
NUMTOYMINTERVAL, which converts a NUMBER or expression that can be implicitly
converted to a NUMBER value to an INTERVAL YEAR TO MONTH literal
TO_DATE, which converts character data to a DATE data type
TO_CHAR, which converts DATE data to character data
TO_DSINTERVAL, which converts a character string to an INTERVAL DAY TO

SECOND value
TO_TIMESTAMP, which converts character data to a value of TIMESTAMP data

type
TO_TIMESTAMP_TZ, which converts character data to a value of TIMESTAMP
WITH TIME ZONE data type
TO_YMINTERVAL, which converts a character string to an INTERVAL YEAR TO
MONTH type
Example 618 shows how to use date functions on date data.

Example 618
Using Date Functions
-- in the following statement you can use MONTHS_BETWEEN to compute months

-- employed for employees and then truncate the results to the whole month
-- note the use of the label (alias) "Months Employed" for the computed column
SELECT employee_id, TRUNC(MONTHS_BETWEEN(SYSDATE, HIRE_DATE)) "Months Employed"
FROM employees;
-- the following displays the year hired for each employee id
SELECT employee_id, EXTRACT(YEAR FROM hire_date) "Year Hired" FROM employees;
Example 619 shows how to use date functions with format masks.
Example 619
Using Date Functions With Format Masks
-- use TO_DATE with a format mask to display or enter dates differently than the
-- current default date format
-- the following displays 1998 with the 'DD-MON-RR' format mask
SELECT TO_CHAR(TO_DATE('27-OCT-98', 'DD-MON-RR') ,'YYYY') "Year" FROM DUAL;
-- note that 'YY' in a format mask denotes the year in the current century
-- the following displays 2098 with the 'DD-MON-YY' format mask
SELECT TO_CHAR(TO_DATE('27-OCT-98', 'DD-MON-YY') ,'YYYY') "Year" FROM DUAL;
-- the following displays the date and time with a datetime format mask
SELECT TO_TIMESTAMP ('10-Sep-05 14:10:10.123000', 'DD-Mon-RR HH24:MI:SS.FF')
FROM DUAL;
-- the following displays the system date and time with a format mask
SELECT TO_CHAR(SYSDATE, 'MM-DD-YYYY HH24:MI:SS') "Now" FROM DUAL;
6.5.7 Using Aggregate Functions

Group functions operate on sets of rows to give one result per group. These sets may
comprise the entire table or the table split into groups.
Example 618 shows how to use aggregate functions on collections of data in the
database. Aggregate functions include COUNT, MAX, MIN, and SUM. The GROUP BY
clause is used to select groups of rows by a specified expression and returns one row
of summary information for each group.
Example 620
Using Aggregate Functions
-- you can use COUNT to count the employees with manager 122
-- note the use of a column alias Employee Count
SELECT COUNT(*) "Employee Count" FROM employees WHERE manager_id = 122;
-- count the employees grouped by manager, also sort the groups
SELECT COUNT(*) "Employee Count", manager_id FROM employees
GROUP BY manager_id ORDER BY manager_id;
-- you can use MIN to find the minimum salary for employees with manager 122
SELECT MIN(salary) FROM employees WHERE manager_id = 122;
-- this computes the minimum and maximum salary by job_id groups
-- the job_ids groups are sorted in alphabetical order
SELECT MIN(salary), MAX(salary), job_id FROM employees
GROUP BY job_id ORDER BY job_id;
6.6 Using SQL Data Definition Language Statements

Data definition language (DDL) statements include CREATE, ALTER, and DROP for
defining database objects. When managing database objects, Raptor provides a simple
and easy-to-use interface that can be utilized instead of SQL DDL statements.
In this guide, some basic SQL DDL statements are used in the code examples and a
brief description of some DDL statements are discussed here.
Creating a Table With SQL
Creating and Modifying an Index With SQL
Creating and Modifying a Constraint With SQL
Altering a Table With SQL
Dropping a Table With SQL
Creating and Dropping a Sequence
Creating and Dropping a Synonym
6.6.1 Creating a Table With SQL

To create a database object, such as a table, use the SQL CREATE statement as shown in
Example 621. When you create a table, you need to provide data types for each
column. For more information about tables, see Managing Tables.
Example 621
Creating a Simple Table
-- create a simple table for keeping track of birthdays

CREATE TABLE my_birthdays
( first_name
VARCHAR2(20),
last_name
VARCHAR2(25),
bday_date
DATE
);
Optionally, you can provide constraints as shown inExample 622. The use of
constrains is discussed in Ensuring Data Integrity With Constraints.
Example 622
Creating a Table With Constraints
-- create a table similar to the employees table in the HR schema

CREATE TABLE my_employees
( employee_id
NUMBER(6),
first_name
VARCHAR2(20),
last_name
VARCHAR2(25) CONSTRAINT my_emp_last_name_nn NOT NULL,
email
VARCHAR2(25) CONSTRAINT my_emp_email_nn NOT NULL,
phone_number
VARCHAR2(20),
hire_date
job_id
salary
commission_pct
manager_id
department_id
CONSTRAINT
CONSTRAINT
);
DATE DEFAULT SYSDATE CONSTRAINT my_emp_hire_date_nn NOT NULL,

VARCHAR2(10) CONSTRAINT my_emp_job_nn NOT NULL,
NUMBER(8,2) CONSTRAINT emy_mp_salary_nn NOT NULL,
NUMBER(2,2),
NUMBER(6),
NUMBER(4),
my_emp_salary_min CHECK (salary > 0),
my_emp_email_uk UNIQUE (email)
6.6.2 Creating and Modifying an Index With SQL

To create, modify, or drop an index, use the SQL CREATE, ALTER, or DROP INDEX
statement as shown in Example 623.
Example 623
Creating, Modifying, and Dropping an Index
-- create a new index on the employees table using the email column
CREATE INDEX email_ix
ON employees (email);
-- disable the index
ALTER INDEX email_ix
RENAME TO my_email_ix;
-- drop the index
DROP INDEX my_email_ix;
-- create an index on a single column to make queries faster on that column
CREATE INDEX emp_last_name_ix ON employees (last_name);
DROP INDEX emp_last_name_ix;
-- create an index on two columns to make queries faster on the first column
-- or both columns
CREATE INDEX emp_mgr_id_ix ON employees (employee_id, manager_id);
DROP INDEX emp_mgr_id_ix;
-- a function-based index precalculates the result and speeds up queries that
-- use the function for searching or sorting, in this case UPPER(last_name)
CREATE INDEX emp_upper_last_name_ix ON employees (UPPER(last_name));
DROP INDEX emp_upper_last_name_ix;
6.6.3 Creating and Modifying a Constraint With SQL

To add or a modify a constraint on a table, use the SQL ALTER statement as shown in
Example 624.
Example 624
Creating and Altering a Constraint
-- add a constraint a new constraint

ALTER TABLE my_employees
ADD CONSTRAINT ...
-- remove the constraint on email in the my_employees table
ALTER TABLE my_employees
DROP UNIQUE (email);
6.6.4 Altering a Table With SQL

To alter a database object, such as a table, use the SQL ALTER statement as shown in
Example 625.
Example 625
Altering a Table
-- add a new column to my_birthdays

ALTER TABLE my_birthdays
ADD (age NUMBER(3));
-- rename the my_employees table
ALTER TABLE my_employees RENAME to temp_employees;
6.6.5 Dropping a Table With SQL

To drop (remove completely) a table from the database use the SQL DROP statement as
shown inExample 626. Be very careful when using the DROP statement to remove
database objects.
If you want to delete the rows in the table and keep the table, use the DELETE
statement. See "Deleting Data With the DELETE Statement" on page 6-8.
Example 626
Dropping a Table
-- drop tables from the database

-- use caution when use the DROP statement!
DROP TABLE my_birthdays;
DROP TABLE temp_employees;
6.6.6 Creating and Dropping a Sequence

Example 627 creates a sequence that can be used with the employees table. The
sequence could also be used with other tables. For more information on sequences, see
Managing Sequences.
Example 627
Creating a Sequence
-- create a new sequence to use with the employees table

CREATE SEQUENCE new_employees_seq START WITH 1000 INCREMENT BY 1;
-- to use the sequence, first initialize the sequence with NEXTVAL
SELECT new_employees_seq.NEXTVAL FROM DUAL;
-- after initializing the sequence, use CURRVAL as the next value in the sequence
(new_employees_seq.CURRVAL, 'Pilar', 'Valdivia', 'pilar.valdivia',
'555.111.3333', '01-SEP-05', 'AC_MGR', 9100, .1, 101, 110);
-- query the employees table to check the current value of the sequence
-- which was inserted used as employee_id in the previous INSERT statement
SELECT employee_id, last_name FROM employees WHERE last_name = 'Valdivia';
Example 628 drops the sequence that you previously created.
Example 628
Dropping a Sequence
-- drop the sequence

DROP SEQUENCE new_employees_seq;
6.6.7 Creating and Dropping a Synonym

Example 629 creates a synonym that is alias for the employees table. For more
information on synonyms, see Managing Synonyms.
Example 629
Creating a Synonym
-- create a synonym for the employees table

CREATE SYNONYM emps for HR.employees;
-- query the employees table using the emps synonym
SELECT employee_id, last_name FROM emps WHERE employee_id < 105;
Example 630 drops a synonym.

Example 630
Dropping a Synonym
-- drop the synonym

DROP SYNONYM emps;
7
The topic discusses the development with PL/SQL. It includes the following topics:
Overview of PL/SQL on page 7-1
Entering and Executing PL/SQL Code on page 7-2
Utilizing the Main Features of PL/SQL on page 7-2
Handling PL/SQL Errors on page 7-21

See Also:
PL/SQL User's Guide and Reference for detailed information about

PL/SQL.
PL/SQL Packages and Types Reference for information on packages
supplied by Oracle.
Oracle Database Application Developer's Guide - Fundamentals for
information on dynamic SQL.
information on using PL/SQL to develop Web applications.
7.1 Overview of PL/SQL

PL/SQL is Oracle's procedural language extension to SQL. It provides a server-side,
stored procedural language that is easy-to-use, seamless with SQL, robust, portable,
and secure.
The PL/SQL compiler and interpreter are embedded in Oracle Database, providing
developers with a consistent and leveraged development model on both the client and
the server side. In addition, PL/SQL stored subprograms can be called from Oracle
clients.
PL/SQL enables you to mix SQL statements with procedural constructs. With
PL/SQL, you can create and run PL/SQL program units such as procedures,
functions, and packages. PL/SQL program units generally are categorized as
anonymous blocks, stored subprograms, and packages.
The basic units (procedures, functions, and anonymous blocks) that make up a
PL/SQL program can be nested inside one another.
You can place declarations close to where they are used, such as inside a large
subprogram. The declarations are local to the block and cease to exist when the block
completes, helping to avoid cluttered namespaces for variables and procedures.
PL/SQL: Usage Information 7-1
Entering and Executing PL/SQL Code
You can nest blocks in the executable and exception-handling parts of a PL/SQL block
or subprogram, but not in the declarative part. You can define local subprograms in
the declarative part of any block. You can call local subprograms only from the block
in which they are defined.
Anonymous block
An anonymous block is a PL/SQL block that appears in your application and is
not named or stored in the database. In many applications, PL/SQL blocks can
appear wherever SQL statements can appear. A PL/SQL block groups related
declarations and statements.
Stored or standalone subprogram

A stored or standalone subprogram is a PL/SQL block that Oracle stores in the
database and can be called by name from an application. Subprograms can be
procedures or functions; the difference is that functions return a value when
executed. When you create a stored subprogram, Oracle parses the subprogram
and stores its parsed representation in the database. See Subprograms and
Packages: Usage Information.
Package
A package is a group of subprograms and variable definitions that Oracle stores in
the database. Subprograms and variables in packages can be called from other
packages or subprograms. See Subprograms and Packages: Usage Information.
7.2 Entering and Executing PL/SQL Code

PL/SQL code can be entered and executed from the SQL Workshop or the SQL*Plus
command line.
In the SQL Workshop, you can save your SQL statements as a script file that can be run
as a SQL script with SQL*Plus.
If you use SQL*Plus, simply type in each line of code at the SQL prompt. For
information on using SQL*Plus, see SQL*Plus: Usage Information.
You can create a text file of the PL/SQL code and run that as a SQL script. Using a
script makes correcting mistakes much easier because you only need to make the
necessary updates to correct the problem rather than retyping all the PL/SQL code.
For information on running SQL scripts from SQL*Plus, see Running Scripts From
SQL*Plus.
7.3 Utilizing the Main Features of PL/SQL

PL/SQL combines the data-manipulating power of SQL with the processing power of
procedural languages. You can control program flow with statements like IF and
LOOP. As with other procedural programming languages, you can declare variables,
define procedures and functions, and trap runtime errors.
PL/SQL lets you break complex problems down into easily understandable
procedural code, and reuse this code across multiple applications. When a problem
can be solved through plain SQL, you can issue SQL commands directly inside your
PL/SQL programs, without learning new APIs. PL/SQL data types correspond with
SQL column types, making it easy to interchange PL/SQL variables with data inside a
table.
Using PL/SQL Block Structure
Using Comments
Utilizing the Main Features of PL/SQL
Declaring Variables and Constants
Using Identifiers in PL/SQL
Assigning Values to a Variable With the Assignment Operator
Using Literals
Declaring and Assigning Variables With DEFAULT or NOT NULL
Assigning Values to a Variable With SELECT INTO
Inputting and Outputting Data with PL/SQL
Using %ROWTYPE and %TYPE Attributes to Declare Data Types
Using PL/SQL Control Structures
Using Local PL/SQL Subprograms in PL/SQL Blocks
Working With PL/SQL Data Structures
Processing Queries with PL/SQL
Using Dynamic SQL in PL/SQL
Using Bind Variables
7.3.1 Using PL/SQL Block Structure

As Example 71 shows, a PL/SQL block has three basic parts: a declarative part
(DECLARE), an executable part (BEGIN .. END), and an exception-handling
(EXCEPTION) part that handles error conditions. For a discussion of exception
handling, see "Handling PL/SQL Errors" on page 7-21.
Only the executable part is required. The optional declarative part is written first,
where you define types, variables, and similar items. These items are manipulated in
the executable part. Exceptions raised during execution can be dealt with in the
exception-handling part.
Note the comments that are added to the PL/SQL code. See "Using Comments" on
page 7-4. Also, not the use of DBMS_OUTPUT.PUT_LINE to display output. See
"Inputting and Outputting Data with PL/SQL" on page 7-9.
Example 71 Simple PL/SQL Block
-- the following is an optional declarative part
DECLARE
monthly_salary
NUMBER(6);
number_of_days_worked NUMBER(2);
pay_per_day
NUMBER(6,2);
-- the following is the executable part, from BEGIN to END
BEGIN
monthly_salary := 2290;
number_of_days_worked := 21;
pay_per_day := monthly_salary/number_of_days_worked;
-- the following displays output from the PL/SQL block
DBMS_OUTPUT.PUT_LINE('The pay per day is ' || TO_CHAR(pay_per_day));
-- the following is an optional exception part that handles errors
EXCEPTION
WHEN ZERO_DIVIDE THEN
pay_per_day := 0;
END;
/
For another example of PL/SQL block structure, see Example 78 on page 7-9.
7.3.2 Using Comments

The PL/SQL compiler ignores comments, but you should not. Adding comments to
your program promotes readability and help others understand your code. Generally,
you use comments to describe the purpose and use of each code segment. PL/SQL
supports single-line and multi-line comment styles.
Single-line comments begin with a double hyphen (--) anywhere on a line and extend
to the end of the line. Multi-line comments begin with a slash-asterisk (/*), end with
an asterisk-slash (*/), and can span multiple lines. See Example 72.
Example 72 Using Comments
DECLARE -- Declare variables here.
monthly_salary
NUMBER(6); -- This is the monthly salary.
number_of_days_worked NUMBER(2); -- This is the days in one month.
pay_per_day
NUMBER(6,2); -- Calculate this value.
BEGIN
-- First assign values to the variables.
monthly_salary := 2290;
number_of_days_worked := 21;
-- Now calculate the value on the following line.
pay_per_day := monthly_salary/number_of_days_worked;
-- the following displays output from the PL/SQL block
DBMS_OUTPUT.PUT_LINE('The pay per day is ' || TO_CHAR(pay_per_day));
EXCEPTION
/* This is a simple example of an exeception handler to trap division by zero.
In actual practice, it would be best to check whether a variable is
zero before using it as a divisor. */
pay_per_day := 0; -- set to 0 if divisor equals 0
END;
/
While testing or debugging a program, you might want to disable a line of code. The
following example shows how you can disable a single line by making it a comment:
-- pay_per_day := monthly_salary/number_of_days_worked;
You can use multi-line comment delimiters to comment-out large sections of code.
7.3.3 Declaring Variables and Constants

Variables can have any SQL data type, such as VARCHAR2, DATE, or NUMBER, or a
PL/SQL-only data type, such as BOOLEAN or PLS_INTEGER. You can also declare
nested tables, variable-size arrays (varrays for short), and records using the TABLE,
VARRAY, and RECORD composite data types. See "Working With PL/SQL Data
Structures" on page 7-17.
Declaring a constant is like declaring a variable except that you must add the keyword
CONSTANT and immediately assign a value to the constant. No further assignments to
the constant are allowed. For an example, see avg_days_worked_month in

Example 73.
For example, assume that you want to declare variables for employee data, such as
employee_id to hold 6-digit numbers and active_employee to hold the Boolean
value TRUE or FALSE. You declare these and related employee variables and constants
as shown in Example 73.
Note that there is a semi-colon (;) at the end of each line in the declaration section.
Also, note the use of the NULL statement which enables you to execute and test the
PL/SQL block.
You can choose any naming convention for variables that is appropriate for your
application. For example, you could begin each variable name with the v_ prefix to
emphasize that these are variable names.
Example 73 Declaring Variables in PL/SQL
DECLARE -- declare the variables in this section
last_name
VARCHAR2(30);
first_name
VARCHAR2(25);
employee_id
NUMBER(6);
active_employee
BOOLEAN;
monthly_salary
NUMBER(6);
pay_per_day
NUMBER(6,2);
avg_days_worked_month CONSTANT NUMBER(2) := 21; -- a constant variable
BEGIN
NULL; -- NULL statement does nothing, allows this block to executed and tested
END;
/
See Also: PL/SQL User's Guide and Reference for information on data
types used with PL/SQL, including the PL/SQL BOOLEAN and PLS_
INTEGER data types
7.3.4 Using Identifiers in PL/SQL

You use identifiers to name PL/SQL program items and units, such as constants,
variables, exceptions, and subprograms. An identifier consists of a letter optionally
followed by more letters, numerals, dollar signs, underscores, and number signs.
The declaration section in Example 74 illustrates some valid identifiers. You can see
additional examples of valid identifiers for variable names in Example 72 on page 7-4
and Example 73 on page 7-5.
Example 74 Valid Identifiers for Variables
DECLARE -- all declarations use valid identifiers
x
NUMBER;
t2
NUMBER;
phone#
VARHCAR2(12);
credit_limit
NUMBER;
oracle$number
NUMBER;
money$$$tree
NUMBER;
SN##
VARCHAR2(9);
try_again
BOOLEAN;
BEGIN
NULL;
END;
/
Characters such as hyphens, slashes, and spaces are not allowed. For example the
following identifiers are not allowed:
mine&yours is not allowed because of the ampersand
debit-amount is not allowed because of the hyphen
on/off is not allowed because of the slash
user id is not allowed because of the space
You can use upper, lower, or mixed case to write identifiers. PL/SQL is not case
sensitive except within string and character literals. Every character, including dollar
signs, underscores, and number signs, is significant. If the only difference between
identifiers is the case of corresponding letters, PL/SQL considers them the same, as in
the following:
lastname is same as LASTNAME and LastName
LastName is the same as lastname and LASTNAME
LASTNAME is same as lastname and LastName
The size of an identifier cannot exceed 30 characters. Identifiers should be descriptive.
When possible, avoid obscure names such as cpm. Instead, use meaningful names such
as cost_per_thousand.
Some identifiers, called reserved words or keywords, have a special syntactic meaning
to PL/SQL. For example, the words BEGIN and END are reserved. Often, reserved
words and keywords are written in upper case for readability. Neither reserved words
or keywords should be used as identifiers and the use can cause compilation errors.
See Also: PL/SQL User's Guide and Reference for information on
PL/SQL reserved words and keywords
7.3.5 Assigning Values to a Variable With the Assignment Operator

You can assign values to a variable in several ways. One way uses the assignment
operator (:=), a colon followed by an equal sign, as shown in Example 75. You place
the variable to the left of the operator and an expression, including function calls, to
the right. Note that you can assign a value to a variable when it is declared.
Example 75 Assigning Values to Variables With the Assignment Operator
DECLARE -- declare and assiging variables
wages
NUMBER(6,2);
hours_worked
NUMBER := 40;
hourly_salary NUMBER := 22.50;
bonus
NUMBER := 150;
country
VARCHAR2(128);
counter
NUMBER := 0;
done
BOOLEAN := FALSE;
valid_id
BOOLEAN;
BEGIN
wages := (hours_worked * hourly_salary) + bonus; -- compute wages
country := 'France'; -- assign a string literal
country := UPPER('Canada'); -- assign an uppercase string literal
done := (counter > 100); -- assign a BOOLEAN, in this case FALSE
valid_id := TRUE; -- assign a BOOLEAN
END;
/
7.3.6 Using Literals

A literal is an explicit numeric, character, string, or BOOLEAN value not represented by
an identifier. For example, 147 is a numeric literal and FALSE is a BOOLEAN literal.
Numeric Literals
Two kinds of numeric literals can be used in arithmetic expressions: integers and reals.
An integer literal is an optionally signed whole number without a decimal point, such
as +6. A real literal is an optionally signed whole or fractional number with a decimal
point, such as -3.14159. PL/SQL considers a number such as 25. to be real even
though it has an integral value.
Numeric literals cannot contain dollar signs or commas, but can be written using
scientific notation. Simply suffix the number with an E (or e) followed by an
optionally signed integer, such as -9.5e-3. E (or e) stands for times ten to the power
of.
Character Literals
A character literal is an individual character enclosed by single quotes (apostrophes),
such as '(' or '7'. Character literals include all the printable characters in the
PL/SQL character set: letters, numerals, spaces, and special symbols.
PL/SQL is case sensitive within character literals. For example, PL/SQL considers the
character literals 'Z' and 'z' to be different. Also, the character literals '0'..'9' are
not equivalent to integer literals but can be used in arithmetic expressions because
they are implicitly convertible to integers.
String Literals
A character value can be represented by an identifier or explicitly written as a string
literal, which is a sequence of zero or more characters enclosed by single quotes, such
as 'Hello, world!' and '$1,000,000'. All string literals except the null string ('')
have data type CHAR.
PL/SQL is case sensitive within string literals. For example, PL/SQL considers the
following string literals 'baker' and 'Baker' to be different:
To represent an apostrophe within a string, you can write two single quotes (''),
which is not the same as writing a double quote ("). Doubling the quotation marks
within a complicated literal, particularly one that represents a SQL statement, can be
tricky. You can also define your own delimiter characters for the literal. You choose a
character that is not present in the string, and then do not need to escape other single
quotation marks inside the literal, such as the following string.
q'!I'm using the exclamation point for a delimiter here.!'
BOOLEAN Literals
BOOLEAN literals are the predefined values TRUE, FALSE, and NULL. NULL stands for a
missing, unknown, or inapplicable value. Remember, BOOLEAN literals are values, not
strings. For example, TRUE is no less a value than the number 25.
Datetime Literals
Datetime literals have various formats depending on the datetime data type, such as
'14-SEP-05' or '14-SEP-05 09:24:04 AM'.
Example 76 shows some examples of the use of literals.
Example 76 Using Literals

DECLARE -- declare and assign variables
number1 PLS_INTEGER := 32000; -- numeric literal
number2 NUMBER(8,3);
char1
VARCHAR2(1) := 'x'; -- character literal
char2
VARCHAR2(1000);
boolean BOOLEAN := TRUE; -- BOOLEAN literal
date1
DATE := '11-AUG-2005'; -- DATE literal
time1
TIMESTAMP;
time2
TIMESTAMP WITH TIME ZONE;
BEGIN
number2 := 3.125346e3; -- numeric literal
number2 := -8300.00; -- numeric literal
number2 := -14; -- numeric literal
char2 := q'!I'm writing an example string.!'; -- string literal
char2 := 'I''m writing an example string.'; -- need two single quotes here
time1 := '11-AUG-2005 11:01:01 PM'; -- TIMESTAMP literal
time2 := '11-AUG-2005 09:26:56.66 PM +02:00';
END;
/
See Also:
Oracle Database SQL Reference for information on the syntax for

literals and the date and time types.
examples of performing date and time arithmetic.
PL/SQL User's Guide and Reference for information on using literals
with PL/SQL.
7.3.7 Declaring and Assigning Variables With DEFAULT or NOT NULL

You can use the keyword DEFAULT instead of the assignment operator to initialize
variables. Use DEFAULT for variables that have a typical value. Use the assignment
operator for variables (such as counters and accumulators) that have no typical value.
You can also use DEFAULT to initialize subprogram parameters, cursor parameters,
and fields in a user-defined record.
Besides assigning an initial value, declarations can impose the NOT NULL constraint so
that assigning a NULL raises an error. The NOT NULL constraint must be followed by an
initialization clause.
In Example 77 the declaration for avg_days_worked_month uses the DEFAULT to
assign a value of 21 and the declarations for active_employee and monthly_
salary use the NOT NULL constraint.
Example 77 Using DEFAULT and NOT NULL
DECLARE -- declare and assign variables
last_name
VARCHAR2(30);
first_name
VARCHAR2(25);
employee_id
NUMBER(6);
active_employee
BOOLEAN NOT NULL := TRUE; -- value cannot be NULL
monthly_salary
NUMBER(6) NOT NULL := 2000; -- value cannot be NULL
pay_per_day
NUMBER(6,2);
employee_count
NUMBER(6) := 0;
avg_days_worked_month NUMBER(2) DEFAULT 21; -- assign a default value
BEGIN
NULL; -- NULL statement does nothing, allows this block to executed and tested
END;
/
7.3.8 Assigning Values to a Variable With SELECT INTO

Another way to assign values to a variable is by selecting (or fetching) database values
into it. In Example 78, 10% of an employee's salary is selected into the bonus
variable. Now you can use the bonus variable in another computation or insert its
value into a database table.
In the example, DBMS_OUTPUT.PUT_LINE is used to display output from the PL/SQL
program. For more information, see "Inputting and Outputting Data with PL/SQL" on
page 7-9.
Example 78 Assigning Values to Variables by SELECTing INTO
DECLARE -- declare and assign values
bonus NUMBER(8,2);
emp_id NUMBER(6) := 100; -- declare variable and assign a test value
BEGIN
-- retreive a value from the employees table and assign to the bonus variable
SELECT salary * 0.10 INTO bonus FROM employees
WHERE employee_id = emp_id;
DBMS_OUTPUT.PUT_LINE ( 'Employee: ' || TO_CHAR(emp_id)
|| ' Bonus: ' || TO_CHAR(bonus) ); -- display data
END;
/
7.3.9 Inputting and Outputting Data with PL/SQL

Most PL/SQL input and output is through SQL statements, to store data in database
tables or query those tables. All other PL/SQL I/O is done through APIs that interact
with other programs. For example, the DBMS_OUTPUT package has procedures such as
PUT_LINE. To see the result outside of PL/SQL requires another program, such as
SQL*Plus, to read and display the data passed to DBMS_OUTPUT. SQL*Plus does not
display DBMS_OUTPUT data unless you first issue the SQL*Plus command SET
SERVEROUTPUT ON. For information on SQL*Plus SET command, see SQL*Plus SET
Commands .
Example 79 show the use of DBMS_OUTPUT.PUTLINE. Note the use of SET
SERVEROUTPUT ON to enable output.
Example 79 Using DBMS_OUTPUT to Display Output
-- enable SERVEROUTPUT in SQL*Plus to display with DBMS_OUTPUT.PUT_LINE
-- this enables SERVEROUTPUT for this SQL*Plus session only
SET SERVEROUTPUT ON
DECLARE
answer VARCHAR2(20); -- declare a variable
BEGIN
-- assign a value to a variable
answer := 'Maybe';
-- use PUT_LINE to display data from the PL/SQL block
DBMS_OUTPUT.PUT_LINE( 'The answer is: ' || answer );
END;
/
The DBMS_OUTPUT package is a predefined Oracle package. For information about

Oracle supplied packages, see Oracle Product-Specific Packages.
See Also:
SQL*Plus User's Guide and Reference for information SQL*Plus

commands.
PL/SQL Packages and Types Reference.for information about Oracle
supplied packages.
7.3.10 Using %ROWTYPE and %TYPE Attributes to Declare Data Types

As part of the declaration for each PL/SQL variable, you declare its data type. Usually,
this data type is one of the types shared between PL/SQL and SQL, such as NUMBER or
VARCHAR2. For easier maintenance of code that interacts with the database, you can
also use the special qualifiers %ROWTYPE and %TYPE to declare variables that hold
table columns or table rows.
7.3.10.1 Using the %ROWTYPE Attribute to Declare Variables

For easier maintenance of code that interacts with the database, you can use the
%ROWTYPE attribute to declare a variable that represents a row in a table. A PL/SQL
record is the data type that stores the same information as a row in a table.
In PL/SQL, records are used to group data. A record consists of a number of related
fields in which data values can be stored. The record can store an entire row of data
selected from the table or fetched from a cursor or cursor variable. For information on
records, see "Using Records" on page 7-18.
Columns in a row and corresponding fields in a record have the same names and data
types. In Example 710, you declare a record named emp_rec. Its fields have the same
names and data types as the columns in the employees table. You use dot notation to
reference fields, such as emp_rec.last_name.
In Example 710, SELECT is used to store row information from the employees table
into the emp_rec record. When you execute the SELECT INTO statement, the value in
the first_name column of the employees table is assigned to the first_name field
of emp_rec, the value in the last_name column is assigned to the last_name field
of emp_rec, and so on.
Example 710
Using %ROWTYPE with a Record
DECLARE -- declare variables

-- declare record variable that represents a row fetched from the employees table
emp_rec employees%ROWTYPE; -- declare variable with %ROWTYPE attribute
BEGIN
SELECT * INTO emp_rec FROM EMPLOYEES WHERE employee_id = 120; -- retrieve record
DBMS_OUTPUT.PUT_LINE('Employee name: ' || emp_rec.first_name || ' '
|| emp_rec.last_name); -- display
END;
/
Declaring variables with %ROWTYPE has several advantages. First, you do not need to
know the exact data type of the table columns. Second, if you change the database
definition of any of the table columns, the data types associated with the %ROWTYPE
declaration change accordingly at run time.
%ROWTYPE
7.3.10.2 Using the %TYPE Attribute to Declare Variables

The %TYPE attribute provides the data type of a variable or table column. This is
particularly useful when declaring variables that will hold values of a table column.
For example, suppose you want to declare variables as the same data type as columns
employee_id and last_name in table employees. To declare variables named
empid and emplname that have the same data type as the table columns, use dot
notation and the %TYPE attribute. See Example 711.
Example 711
Using %TYPE With Table Columns
DECLARE -- declare variables using %TYPE attribute

empid
employees.employee_id%TYPE; -- employee_id data type is NUMBER(6)
emplname employees.last_name%TYPE; -- last_name data type is VARCHAR2(25)
BEGIN
empid
:= 100301; -- this is OK because it fits in NUMBER(6)
-empid := 3018907; -- this is too large and will cause an overflow
emplname := 'Patel'; -- this is OK because it fits in VARCHAR2(25)
DBMS_OUTPUT.PUT_LINE('Employee Id: ' || empid); -- display data
DBMS_OUTPUT.PUT_LINE('Employee name: ' || emplname); -- display data
END;
/
Declaring variables with %TYPE has two advantages. First, you need not know the
exact data type of the table columns. Second, if you change the database definition of
columns, such as employee_id or last_name, the data types of empid and
emplname in Example 711 change accordingly at run time.
%TYPE
7.3.11 Using PL/SQL Control Structures

Control structures are the most important PL/SQL extension to SQL. Not only does
PL/SQL let you manipulate Oracle data, it lets you process the data using conditional,
iterative, and sequential flow-of-control statements such as IF-THEN-ELSE, CASE,
FOR-LOOP, WHILE-LOOP, EXIT-WHEN, and GOTO.
7.3.11.1 Conditional Control With IF-THEN

Often, it is necessary to take alternative actions depending on circumstances. The
IF-THEN statement lets you execute a sequence of statements conditionally. The forms
of the statement can be IF-THEN, IF-THEN-ELSE, or IF-THEN-ELSEIF-ELSE. The
IF clause checks a condition, the THEN clause defines what to do if the condition is
true and the ELSE clause defines what to do if the condition is false or null.
Example 712 shows a simple use of the IF-THEN statement.
Example 712
Using a Simple IF-THEN Statement
DECLARE
sales NUMBER(8,2) := 10100;
quota NUMBER(8,2) := 10000;
bonus NUMBER(6,2);
emp_id NUMBER(6) := 120; -- use employee 120 for testing
BEGIN
IF sales > (quota + 200) THEN
bonus := (sales - quota)/4;
UPDATE employees SET salary = salary + bonus WHERE employee_id = emp_id;
END IF;
END;
/
Example 713 shows the use of IF-THEN-ELSEIF-ELSE to determine the salary raise
an employee receives based on the hire date of the employee.
Example 713
Using the IF-THEN-ELSEIF Statement
DECLARE
bonus NUMBER(6,2);
emp_id NUMBER(6) := 120;
hire_date DATE;
BEGIN
SELECT hire_date INTO hire_date FROM employees WHERE employee_id = 120;
IF hire_date > TO_DATE('01-JAN-98') THEN
bonus := 500;
ELSIF hire_date > TO_DATE('01-JAN-96') THEN
bonus := 1000;
ELSE
bonus := 1500;
END IF;
UPDATE employees SET salary = salary + bonus WHERE employee_id = emp_id;
END;
/
7.3.11.2 Conditional Control With the CASE Statement

To choose among several values or courses of action, you can use CASE constructs. The
CASE expression evaluates a condition and returns a value for each case. The case
statement evaluates a condition and performs an action, such as an entire PL/SQL
block, for each case. When possible, rewrite lengthy IF-THEN-ELSIF statements as
CASE statements because the CASE statement is more readable and more efficient.
Example 714 shows a simple CASE statement.
Example 714
Using the CASE-WHEN Statement
DECLARE
grade CHAR(1);
BEGIN
grade := 'B';
CASE grade
WHEN 'A' THEN DBMS_OUTPUT.PUT_LINE('Excellent');
WHEN 'B' THEN DBMS_OUTPUT.PUT_LINE('Very Good');
WHEN 'C' THEN DBMS_OUTPUT.PUT_LINE('Good');
WHEN 'D' THEN DBMS_OUTPUT.PUT_LINE('Fair');
WHEN 'F' THEN DBMS_OUTPUT.PUT_LINE('Poor');
ELSE DBMS_OUTPUT.PUT_LINE('No such grade');
END CASE;
END;
/
Example 715 determines the salary raise an employee receives based on the current
salary of the employee and the job Id. This complex example combines the CASE
expression with IF-THEN-ELSE statements.
Example 715
Using the IF-THEN_ELSE and CASE Statement

jobid
employees.job_id%TYPE;
empid
employees.employee_id%TYPE := 115;
sal
employees.salary%TYPE;
sal_raise NUMBER(3,2);
BEGIN
-- retrieve data from employees and assign to variables jobid and sal
SELECT job_id, salary INTO jobid, sal from employees WHERE employee_id = empid;
CASE -- check for conditions
WHEN jobid = 'PU_CLERK' THEN
IF sal < 3000 THEN sal_raise := .08;
ELSE sal_raise := .07;
END IF;
WHEN jobid = 'SH_CLERK' THEN
END IF;
WHEN jobid = 'ST_CLERK' THEN
END IF;
ELSE
BEGIN
-- if no conditions met, then the following
DBMS_OUTPUT.PUT_LINE('No raise for this job: ' || jobid);
END;
END CASE;
UPDATE employees SET salary = salary + salary * sal_raise
WHERE employee_id = empid; -- update a record in the employees table
COMMIT;
END;
/
A sequence of statements that uses query results to select alternative actions is

common in database applications. Another common sequence inserts or deletes a row
only if an associated entry is found in another table. You can bundle these common
sequences into a PL/SQL block using conditional logic.
7.3.11.3 Iterative Control With LOOPs

LOOP statements let you execute a sequence of statements multiple times. You place
the keyword LOOP before the first statement in the sequence and the keywords END
LOOP after the last statement in the sequence.
The FOR-LOOP statement lets you specify a range of integers, then execute a sequence
of statements once for each integer in the range. In Example 716 the loop displays the
number and the square of the number for numbers 1 to 10. inserts 100 numbers, square
roots, squares, and the sum of squares into a database table:
Example 716
Using the FOR-LOOP
BEGIN
-- use a FOR loop to process a series of numbers
FOR i in 1..10 LOOP
DBMS_OUTPUT.PUT_LINE('Number: ' || TO_CHAR(i) || ' Square: ' || TO_CHAR(i*i));
END LOOP;
END;
/
The WHILE-LOOP statement associates a condition with a sequence of statements.

Before each iteration of the loop, the condition is evaluated. If the condition is true, the
sequence of statements is executed, then control resumes at the top of the loop. If the
condition is false or null, the loop is bypassed and control passes to the next statement.
In Example 717, you find the first employee who has a salary over $15000 and is
higher in the chain of command than employee 120:
Example 717
Using WHILE-LOOP for Control
-- create a temporary table for this example

CREATE TABLE temp (tempid NUMBER(6), tempsal NUMBER(8,2), tempname VARCHAR2(25));
sal
employees.salary%TYPE := 0;
mgr_id
employees.manager_id%TYPE;
lname
employees.last_name%TYPE;
starting_empid employees.employee_id%TYPE := 120;
BEGIN
SELECT manager_id INTO mgr_id FROM employees
WHERE employee_id = starting_empid; -- retrieve data from employees
-- use WHILE LOOP to process data
WHILE sal <= 15000 LOOP -- loop until sal > 15000
SELECT salary, manager_id, last_name INTO sal, mgr_id, lname
FROM employees WHERE employee_id = mgr_id;
END LOOP;
INSERT INTO temp VALUES (NULL, sal, lname); -- insert NULL for tempid in table
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
INSERT INTO temp VALUES (NULL, NULL, 'Not found'); -- insert NULLs
COMMIT;
END;
/
-- display rows in table temp
SELECT * FROM temp;
-- drop temporary table
DROP TABLE temp;
The EXIT-WHEN statement lets you complete a loop if further processing is impossible
or undesirable. When the EXIT statement is encountered, the condition in the WHEN
clause is evaluated. If the condition is true, the loop completes and control passes to
the next statement. In Example 718, the loop completes when the value of total
exceeds 25,000:
Example 718
Using the EXIT-WHEN Statement
DECLARE -- declare and assign values to variables

total
NUMBER(9) := 0;
counter NUMBER(6) := 0;
BEGIN
LOOP
counter := counter + 1; -- increment counter variable
total := total + counter * counter; -- compute total
-- exit loop when condition is true
EXIT WHEN total > 25000; -- LOOP until condition is met
END LOOP;
DBMS_OUTPUT.PUT_LINE('Counter: ' || TO_CHAR(counter) || ' Total: ' || TO_
CHAR(total)); -- display data
END;
/
7.3.11.4 Sequential Control With GOTO

The GOTO statement lets you branch to a label unconditionally. The label, an
undeclared identifier enclosed by double angle brackets, must precede an executable
statement or a PL/SQL block. When executed, the GOTO statement transfers control to
the labeled statement or block, as shown in Example 719.
Example 719
Using the GOTO Statement

p
VARCHAR2(30);
n
PLS_INTEGER := 37; -- test any integer > 2 for prime, here 37
BEGIN
-- loop through divisors to determine if a prime number
FOR j in 2..ROUND(SQRT(n))
LOOP
IF n MOD j = 0 THEN -- test for prime
p := ' is NOT a prime number'; -- not a prime number
GOTO print_now;
END IF;
END LOOP;
p := ' is a prime number';
<<print_now>>
DBMS_OUTPUT.PUT_LINE(TO_CHAR(n) || p); -- display data
END;
/
7.3.12 Using Local PL/SQL Subprograms in PL/SQL Blocks

Subprograms are named PL/SQL blocks that can be called with a set of parameters
from inside a PL/SQL block. PL/SQL has two types of subprograms: procedures and
functions.
Example 720 is an example of a declaration of a PL/SQL procedure in a PL/SQL
block. Note that the v1 and v2 variables are declared as IN OUT parameters to a
subprogram. An IN OUT parameter passes an initial value that is read inside a
subprogram and then returns a value that has been updated in the subprogram.
Example 720
Declaring a Procedure With IN OUT Parameters
DECLARE -- declare variables and subprograms

fname
VARCHAR2(20) := 'randall';
lname
VARCHAR2(25) := 'dexter';
PROCEDURE upper_name ( v1 IN OUT VARCHAR2, v2 IN OUT VARCHAR2) AS
BEGIN
v1 := UPPER(v1); -- change the string to uppercase
v2 := UPPER(v2); -- change the string to uppercase
END;
BEGIN
DBMS_OUTPUT.PUT_LINE(fname || ' ' || lname ); -- display initial values
upper_name (fname, lname); -- call the procedure with parameters
DBMS_OUTPUT.PUT_LINE(fname || ' ' || lname ); -- display new values
END;
/
Example 721 is an example of a declaration of a PL/SQL function in a PL/SQL block.

Note that the value returned by the function is used directly in the DBMS_
OUTPUT.PUT_LINE statement. Note that the v1 and v2 variables are declared as IN
parameters to a subprogram. An IN parameter passes an initial value that is read
inside a subprogram. Any update to the value of the parameter inside the subprogram
is not accessible outside the subprogram.
Example 721
Declaring a Function With IN Parameters

fname
VARCHAR2(20) := 'randall';
lname
VARCHAR2(25) := 'dexter';
FUNCTION upper_name ( v1 IN VARCHAR2, v2 IN VARCHAR2)
RETURN VARCHAR2 AS
v3
VARCHAR2(45); -- this variable is local to the function
BEGIN
-- build a string that will be returned as the function value
v3 := v1 || ' + ' || v2 || ' = ' || UPPER(v1) || ' ' || UPPER(v2);
RETURN v3; -- return the value of v3
END;
BEGIN
-- call the function and display results
DBMS_OUTPUT.PUT_LINE(upper_name (fname, lname));
END;
/
In Example 722, both a variable and a numeric literal are passed as a parameter to a
more complex procedure.
Example 722
Declaring a Complex Procedure in a PL/SQL Block

empid NUMBER;
PROCEDURE avg_min_max_sal (empid IN NUMBER) IS
jobid
VARCHAR2(10);
avg_sal
NUMBER;
min_sal
NUMBER;
max_sal
NUMBER;
BEGIN
-- determine the job Id for the employee
SELECT job_id INTO jobid FROM employees WHERE employee_id = empid;
-- calculate the average, minimum, and maximum salaries for that job Id
SELECT AVG(salary), MIN(salary), MAX(salary) INTO avg_sal, min_sal, max_sal
FROM employees WHERE job_id = jobid;
-- display data
DBMS_OUTPUT.PUT_LINE ('Employee Id: ' || empid || ' Job Id: ' || jobid);
DBMS_OUTPUT.PUT_LINE ('The average salary for job Id: ' || jobid
|| ' is ' || TO_CHAR(avg_sal));
DBMS_OUTPUT.PUT_LINE ('The minimum salary for job Id: ' || jobid
|| ' is ' || TO_CHAR(min_sal));
DBMS_OUTPUT.PUT_LINE ('The maximum salary for job Id: ' || jobid
|| ' is ' || TO_CHAR(max_sal));
END avg_min_max_sal;
BEGIN
-- call the procedure with several employee Ids
empid := 125;
avg_min_max_sal(empid);
avg_min_max_sal(112);
END;
/
Subprograms can also be declared in packages. You can create subprograms that are
stored in the database. These subprograms can be called from other subprograms,
packages, and SQL statements. See Subprograms and Packages: Usage Information.
7.3.13 Working With PL/SQL Data Structures

Data structure are composite data types that let you work with the essential properties
of data without being too involved with details. After you design a data structure, you
can focus on designing algorithms that manipulate the data structure.
7.3.13.1 Using Cursors

A cursor is a name for a specific private SQL area in which information for processing
the specific statement is kept. PL/SQL uses both implicit and explicit cursors. PL/SQL
implicitly declares a cursor for all SQL data manipulation statements on a set of rows,
including queries that return only one row. You can explicitly declare a cursor for one
row, as shown in Example 710 on page 7-10 declares an explicit cursor.
For queries that return more than one row, you can explicitly declare a cursor to
process the rows individually. See Example 723.
Example 723
Fetching With a Cursor
DECLARE -jobid
lastname
CURSOR c1
declare variables and cursors

employees.job_id%TYPE;
-- variable for job_id
employees.last_name%TYPE; -- variable for last_name
IS SELECT last_name, job_id FROM employees
WHERE job_id LIKE '%CLERK';
employees employees%ROWTYPE;
-- record variable for row
CURSOR c2 is SELECT * FROM employees
WHERE job_id LIKE '%MAN' OR job_id LIKE '%MGR';
BEGIN
OPEN c1; -- open the cursor before fetching
LOOP
FETCH c1 INTO lastname, jobid; -- fetches 2 columns into variables
EXIT WHEN c1%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( RPAD(lastname, 25, ' ') || jobid );
END LOOP;
CLOSE c1;
DBMS_OUTPUT.PUT_LINE( '-------------------------------------' );
OPEN c2;
LOOP
FETCH c2 INTO employees; -- fetches entire row into the employees record
EXIT WHEN c2%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( RPAD(employees.last_name, 25, ' ') ||
employees.job_id );
END LOOP;
CLOSE c2;
END;
/
In Example 723, LIKE is used to specify the records to return with the query. For
information on LIKE, see Restricting Data Using the WHERE Clause.
managing cursors with PL/SQL
7.3.13.2 Using Collections

PL/SQL collection types let you declare high-level data types similar to arrays, sets,
and hash tables found in other languages. In PL/SQL, array types are known as
varrays (short for variable-size arrays), set types are known as nested tables, and hash
table types are known as associative arrays. Each kind of collection is an ordered
group of elements, all of the same type. Each element has a unique subscript that
determines its position in the collection. When declaring collections, you use a TYPE
definition.
To reference an element, use subscript notation with parentheses, as shown in
Example 724.
Example 724
Using a PL/SQL Collection Type

TYPE jobids_array IS VARRAY(12) OF VARCHAR2(10); -- declare VARRAY
jobids jobids_array; -- declare a variable of type jobids_array
howmany NUMBER; -- declare a variable to hold employee count
BEGIN
-- initialize the arrary with some job Id values
jobids := jobids_array('AC_ACCOUNT', 'AC_MGR', 'AD_ASST', 'AD_PRES', 'AD_VP',
'FI_ACCOUNT', 'FI_MGR', 'HR_REP', 'IT_PROG', 'SH_CLERK',
'ST_CLERK', 'ST_MAN');
FOR i IN jobids.FIRST..jobids.LAST LOOP -- loop through all the varray values
-- determine the number of employees for each job Id in the array
SELECT COUNT(*) INTO howmany FROM employees WHERE job_id = jobids(i);
DBMS_OUTPUT.PUT_LINE ( 'Job Id: ' || jobids(i) ||
' Number of employees: ' || TO_CHAR(howmany));
END LOOP;
END;
/
Collections can be passed as parameters, so that subprograms can process arbitrary

numbers of elements.You can use collections to move data into and out of database
tables using high-performance language features known as bulk SQL.
See Also:
PL/SQL User's Guide and Reference for information on PL/SQL

collections.
7.3.13.3 Using Records

Records are composite data structures whose fields can have different data types. You
can use records to hold related items and pass them to subprograms with a single
parameter. When declaring records, you use the TYPE definition.
Example 725 shows how are records are declared.
Example 725
Declaring a Record Type
DECLARE -- declare RECORD type variables

TYPE timerec IS RECORD (hours SMALLINT, minutes SMALLINT);
TYPE meetin_typ IS RECORD (
date_held DATE,
duration timerec, -- nested record
location VARCHAR2(20),
purpose
VARCHAR2(50));
BEGIN
-- NULL does nothing but allows unit to be compiled and tested
NULL;
END;
/
You can use the %ROWTYPE attribute to declare a record that represents a row in a table
or a row from a query result set, without specifying the names and types for the fields.
When using %ROWTYPE, the record type definition is implied and the TYPE keyword is
not necessary, as shown in Example 726.
Example 726
Using %ROWTYPE with a Cursor

CURSOR c1 IS
SELECT * FROM employees
WHERE employee_id = 120; -- declare cursor
-- declare record variable that represents a row fetched from the employees table
employee_rec c1%ROWTYPE; -- declare variable with %ROWTYPE attribute
BEGIN
-- open the explicit cursor c1 and use it to fetch data into employee_rec
OPEN c1;
FETCH c1 INTO employee_rec; -- retrieve record
DBMS_OUTPUT.PUT_LINE('Employee name: ' || employee_rec.last_name); -- display
END;
/
See Also:

records.
7.3.14 Processing Queries with PL/SQL

Processing a SQL query with PL/SQL is like processing files with other languages.
This process includes opening a file, reading the file contents, processing each line,
then closing the file. In the same way, a PL/SQL program issues a query and processes
the rows from the result set as shown in Example 727.
Example 727
Processing Query Results in a LOOP
BEGIN
-- use values from SELECT for FOR LOOP processing
FOR someone IN (SELECT * FROM employees WHERE employee_id < 120 )
LOOP
DBMS_OUTPUT.PUT_LINE('First name = ' || someone.first_name ||
', Last name = ' || someone.last_name);
END LOOP;
END;
/
You can use a simple loop like the one shown here, or you can control the process
precisely by using individual statements to perform the query, retrieve data, and finish
processing.
7.3.15 Using Dynamic SQL in PL/SQL

PL/SQL supports both dynamic and static SQL. Dynamic SQL enables you to build
SQL statements dynamically at runtime while static SQL statements are known in
advance. You can create more general purpose, flexible applications by using dynamic
SQL because the full text of a SQL statement may be unknown at compilation. For
additional information about dynamic SQL, see Oracle Database Application Developer's
Guide - Fundamentals.
To process most dynamic SQL statements, you use the EXECUTE IMMEDIATE
statement. To process a multi-row query (SELECT statement), you use the OPEN-FOR,
FETCH, and CLOSE statements.
Example 728 illustrates several uses of dynamic SQL.

Example 728
Examples of Dynamic SQL
-- create a standalone procedure

CREATE OR REPLACE PROCEDURE raise_emp_salary (column_value NUMBER,
emp_column VARCHAR2, amount NUMBER) IS
column VARCHAR2(30);
sql_stmt VARCHAR2(200);
BEGIN
-- determine if a valid column name has been given as input
SELECT COLUMN_NAME INTO column FROM USER_TAB_COLS
WHERE TABLE_NAME = 'EMPLOYEES' AND COLUMN_NAME = emp_column;
sql_stmt := 'UPDATE employees SET salary = salary + :1 WHERE '
|| column || ' = :2';
EXECUTE IMMEDIATE sql_stmt USING amount, column_value;
IF SQL%ROWCOUNT > 0 THEN
DBMS_OUTPUT.PUT_LINE('Salaries have been updated for: ' || emp_column
|| ' = ' || column_value);
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE ('Invalid Column: ' || emp_column);
END raise_emp_salary;
/
DECLARE
plsql_block
VARCHAR2(500);
BEGIN
-- note the semi-colons (;) inside the quotes '...'
plsql_block := 'BEGIN raise_emp_salary(:cvalue, :cname, :amt); END;';
EXECUTE IMMEDIATE plsql_block USING 110, 'DEPARTMENT_ID', 10;
EXECUTE IMMEDIATE 'BEGIN raise_emp_salary(:cvalue, :cname, :amt); END;'
USING 112, 'EMPLOYEE_ID', 10;
END;
/
DECLARE
sql_stmt
VARCHAR2(200);
column
VARCHAR2(30) := 'DEPARTMENT_ID';
dept_id
NUMBER(4) := 46;
dept_name
VARCHAR2(30) := 'Special Projects';
mgr_id
NUMBER(6) := 200;
loc_id
NUMBER(4) := 1700;
BEGIN
-- note that there is no semi-colon (;) inside the quotes '...'
EXECUTE IMMEDIATE 'CREATE TABLE bonus (id NUMBER, amt NUMBER)';
sql_stmt := 'INSERT INTO departments VALUES (:1, :2, :3, :4)';
EXECUTE IMMEDIATE sql_stmt USING dept_id, dept_name, mgr_id, loc_id;
EXECUTE IMMEDIATE 'DELETE FROM departments WHERE ' || column || ' = :num'
USING dept_id;
EXECUTE IMMEDIATE 'ALTER SESSION SET SQL_TRACE TRUE';
EXECUTE IMMEDIATE 'DROP TABLE bonus';
END;
/
-- rollback the changes
ROLLBACK;
-- delete the procedure
DROP PROCEDURE raise_emp_salary;
Handling PL/SQL Errors
7.3.16 Using Bind Variables

When you embed an INSERT, UPDATE, DELETE, or SELECT SQL statement directly in
your PL/SQL code, PL/SQL turns the variables in the WHERE and VALUES clauses into
bind variables automatically. Oracle can reuse these SQL statement each time the same
code is executed. To run similar statements with different variable values, you can save
parsing overhead by calling a stored procedure that accepts parameters, then issues
the statements with the parameters substituted in the appropriate places.
You do need to specify bind variables with dynamic SQL, in clauses like WHERE and
VALUES where you normally use variables. Instead of concatenating literals and
variable values into a single string, replace the variables with the names of bind
variables (prefixed by a colon) and specify the corresponding PL/SQL variables with
the USING clause. Using the USING clause, instead of concatenating the variables into
the string, reduces parsing overhead and lets Oracle reuse the SQL statements.
In Example 728, :1 and :2 are bind variables for amount and column_value. In the
same example, there are additional bind variables, such as :cvalue, :cname, and
:amt.
7.4 Handling PL/SQL Errors

PL/SQL makes it easy to detect and process error conditions known as exceptions.
When an error occurs, an exception is raised: normal execution stops and control
transfers to special exception-handling code, which comes at the end of any PL/SQL
block. Each different exception is processed by a particular exception handler.
PL/SQL exception handling is different from the manual checking you might be used
to from C programming, where you insert a check to make sure that every operation
succeeded. Instead, the checks and calls to error routines are performed automatically,
similar to the exception mechanism in Java programming.
Predefined exceptions are raised automatically for certain common error conditions
involving variables or database operations. For example, if you try to divide a number
by zero, PL/SQL raises the predefined exception ZERO_DIVIDE automatically. See
"Summary of Predefined PL/SQL Exceptions" on page 7-21.
You can declare exceptions of your own, for conditions that you decide are errors, or to
correspond to database errors that normally result in ORA- error messages. When you
detect a user-defined error condition, you execute a RAISE statement. See "Declaring
PL/SQL Exceptions" on page 7-23.
Summary of Predefined PL/SQL Exceptions
Using the Exception Handler
Declaring PL/SQL Exceptions
Scope Rules for PL/SQL Exceptions
Continuing After an Exception is Raised
7.4.1 Summary of Predefined PL/SQL Exceptions

An internal exception is raised automatically if your PL/SQL program violates an
Oracle rule or exceeds a system-dependent limit. PL/SQL predefines some common
Oracle errors as exceptions. For example, PL/SQL raises the predefined exception NO_
DATA_FOUND if a SELECT INTO statement returns no rows.
To handle unexpected Oracle errors, you can use the OTHERS handler. Within this
handler, you can call the functions SQLCODE and SQLERRM to return the Oracle error
code and message text.
PL/SQL declares predefined exceptions globally in package STANDARD. You need not
declare them yourself. You can write handlers for predefined exceptions using the
names in Table 71.
Table 71
Predefined PL/SQL Exceptions
Exception
Description
ACCESS_INTO_NULL
A program attempts to assign values to the attributes of an uninitialized object
CASE_NOT_FOUND
None of the choices in the WHEN clauses of a CASE statement is selected, and
there is no ELSE clause.
COLLECTION_IS_NULL
A program attempts to apply collection methods other than EXISTS to an

uninitialized nested table or varray, or the program attempts to assign values to
the elements of an uninitialized nested table or varray.
CURSOR_ALREADY_OPEN
A program attempts to open an already open cursor. A cursor must be closed

before it can be reopened. A cursor FOR loop automatically opens the cursor to
which it refers, so your program cannot open that cursor inside the loop.
DUP_VAL_ON_INDEX
A program attempts to store duplicate values in a column that is constrained by

a unique index.
INVALID_CURSOR
A program attempts a cursor operation that is not allowed, such as closing an

unopened cursor.
INVALID_NUMBER
n a SQL statement, the conversion of a character string into a number fails

because the string does not represent a valid number. (In procedural statements,
VALUE_ERROR is raised.) This exception is also raised when the LIMIT-clause
expression in a bulk FETCH statement does not evaluate to a positive number.
LOGIN_DENIED
A program attempts to log on to Oracle with an invalid username or password.
NO_DATA_FOUND
A SELECT INTO statement returns no rows, or your program references a

deleted element in a nested table or an uninitialized element in an index-by
table.
Because this exception is used internally by some SQL functions to signal
completion, you should not rely on this exception being propagated if you raise
it within a function that is called as part of a query.
NOT_LOGGED_ON
A program issues a database call without being connected to Oracle.
PROGRAM_ERROR
PL/SQL has an internal problem.
ROWTYPE_MISMATCH
The host cursor variable and PL/SQL cursor variable involved in an

assignment have incompatible return types. When an open host cursor variable
is passed to a stored subprogram, the return types of the actual and formal
parameters must be compatible.
SELF_IS_NULL
A program attempts to call a MEMBER method, but the instance of the object
type has not been initialized. The built-in parameter SELF points to the object,
and is always the first parameter passed to a MEMBER method.
STORAGE_ERROR
PL/SQL runs out of memory or memory has been corrupted.
SUBSCRIPT_BEYOND_COUNT
A program references a nested table or varray element using an index number

larger than the number of elements in the collection.
SUBSCRIPT_OUTSIDE_LIMIT A program references a nested table or varray element using an index number
(-1 for example) that is outside the legal range.
SYS_INVALID_ROWID
The conversion of a character string into a universal rowid fails because the
character string does not represent a valid rowid.
TIMEOUT_ON_RESOURCE
A time out occurs while Oracle is waiting for a resource.
Table 71 (Cont.) Predefined PL/SQL Exceptions

Exception
Description
TOO_MANY_ROWS
A SELECT INTO statement returns more than one row.
VALUE_ERROR
An arithmetic, conversion, truncation, or size-constraint error occurs. For

example, when your program selects a column value into a character variable, if
the value is longer than the declared length of the variable, PL/SQL aborts the
assignment and raises VALUE_ERROR. In procedural statements, VALUE_ERROR
is raised if the conversion of a character string into a number fails. (In SQL
statements, INVALID_NUMBER is raised.)
ZERO_DIVIDE
A program attempts to divide a number by zero.
7.4.2 Using the Exception Handler

Using exceptions for error handling has several advantages. With exceptions, you can
reliably handle potential errors from many statements with a single exception handler:
Example 729
Managing Multiple Errors With a Single Exception Handler

emp_column
VARCHAR2(30) := 'last_name';
table_name
VARCHAR2(30) := 'emp'; -- set value to raise error
temp_var
VARCHAR2(30);
BEGIN
temp_var := emp_column;
SELECT COLUMN_NAME INTO temp_var FROM USER_TAB_COLS
WHERE TABLE_NAME = 'EMPLOYEES' AND COLUMN_NAME = UPPER(emp_column);
-- processing here
temp_var := table_name;
SELECT OBJECT_NAME INTO temp_var FROM USER_OBJECTS
WHERE OBJECT_NAME = UPPER(table_name) AND OBJECT_TYPE = 'TABLE';
-- processing here
EXCEPTION
WHEN NO_DATA_FOUND THEN -- catches all 'no data found' errors
DBMS_OUTPUT.PUT_LINE ('No Data found for SELECT on ' || temp_var);
END;
/
7.4.3 Declaring PL/SQL Exceptions

Exceptions can be declared only in the declarative part of a PL/SQL block,
subprogram, or package. You declare an exception by introducing its name, followed
by the keyword EXCEPTION. In Example 730, you declare an exception named
past_due that is raised when the due_date is less than the today's date.
Exception and variable declarations are similar. But remember, an exception is an error
condition, not a data item. Unlike variables, exceptions cannot appear in assignment
statements or SQL statements. However, the same scope rules apply to variables and
exceptions.
7.4.4 Scope Rules for PL/SQL Exceptions

You cannot declare an exception twice in the same block. You can, however, declare the
same exception in two different blocks.
Exceptions declared in a block are considered local to that block and global to all its
sub-blocks. Because a block can reference only local or global exceptions, enclosing
blocks cannot reference exceptions declared in a sub-block.
If you redeclare a global exception in a sub-block, the local declaration prevails. The
sub-block cannot reference the global exception, unless the exception is declared in a
labeled block and you qualify its name with the block label:
block_label.exception_name
Example 730 illustrates the scope rules:
Example 730
Scope of PL/SQL Exceptions
DECLARE
past_due EXCEPTION;
acct_num NUMBER;
BEGIN
DECLARE ---------- sub-block begins
past_due EXCEPTION; -- this declaration prevails
acct_num NUMBER;
due_date DATE := SYSDATE - 1; -- set on purpose to raise exception
todays_date DATE := SYSDATE;
BEGIN
IF due_date < todays_date THEN
RAISE past_due; -- this is not handled
END IF;
END; ------------- sub-block ends
EXCEPTION
WHEN past_due THEN -- does not handle raised exception
DBMS_OUTPUT.PUT_LINE('Handling PAST_DUE exception.');
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Could not recognize PAST_DUE_EXCEPTION in this scope.');
END;
/
The enclosing block does not handle the raised exception because the declaration of
past_due in the sub-block prevails. Though they share the same name, the two
past_due exceptions are different, just as the two acct_num variables share the same
name but are different variables. Thus, the RAISE statement and the WHEN clause refer
to different exceptions. To have the enclosing block handle the raised exception, you
must remove its declaration from the sub-block or define an OTHERS handler.
7.4.5 Continuing After an Exception is Raised

By default, you put an exception handler at the end of a subprogram to handle
exceptions that are raised anywhere inside the subprogram. To continue executing
from the spot where an exception happens, enclose the code that might raise an
exception inside another BEGIN-END block with its own exception handler. For
example, you might put separate BEGIN-END blocks around groups of SQL statements
that might raise NO_DATA_FOUND, or around arithmetic operations that might raise
DIVIDE_BY_ZERO. By putting a BEGIN-END block with an exception handler inside a
loop, you can continue executing the loop even if some loop iterations raise
exceptions.
You can still handle an exception for a statement, then continue with the next
statement. Place the statement in its own sub-block with its own exception handlers. If
an error occurs in the sub-block, a local handler can catch the exception. When the
sub-block ends, the enclosing block continues to execute at the point where the
sub-block ends, as shown in Example 731.
Example 731
Continuing After an Exception
-- create a temporary table for this example

CREATE TABLE employees_temp AS
SELECT employee_id, salary, commission_pct FROM employees;
DECLARE
sal_calc NUMBER(8,2);
BEGIN
INSERT INTO employees_temp VALUES (303, 2500, 0);
BEGIN -- sub-block begins
SELECT salary / commission_pct INTO sal_calc FROM employees_temp
WHERE employee_id = 303;
EXCEPTION
sal_calc := 2500;
END; -- sub-block ends
INSERT INTO employees_temp VALUES (304, sal_calc/100, .1);
EXCEPTION
NULL;
END;
/
-- view the results
SELECT * FROM employees_temp WHERE employee_id = 303 OR employee_id = 304;
-- drop the temporary table
DROP TABLE employees_temp;
In this example, if the SELECT INTO statement raises a ZERO_DIVIDE exception, the
local handler catches it and sets sal_calc to 2500. Execution of the handler is
complete, so the sub-block terminates, and execution continues with the INSERT
statement.
8
Subprograms and Packages: Usage
Information
The topic discusses the development of packages and subprograms with PL/SQL. It
includes the following topics:
Overview of Packages and Subprograms
Managing Subprograms
Managing Packages
Oracle Product-Specific Packages

See Also:
"Using PL/SQL Packages" in PL/SQL User's Guide and Reference for

additional information on PL/SQL packages.
"Using PL/SQL Subprograms" in PL/SQL User's Guide and
Reference for information on PL/SQL subprograms
Many examples use the Oracle HR sample schema. For

information on the sample schemas, see Oracle Database Sample
Schemas.
Note:
8.1 Overview of Packages and Subprograms

Oracle offers the capability to store programs in the database. This functionality
enables commonly required code to be written and tested once and then accessed by
any application that requires the code. Database-resident program units also ensure
that the same processing is applied to the data when the code is invoked, making the
development of applications easier and providing consistency between developers.
You can write database-resident programs in PL/SQL and manage source types such
as PL/SQL packages, procedures, functions, and triggers. The actions include creating,
compiling, creating synonyms for, granting privileges on, and showing dependencies
for these source types.
Subprograms and Packages: Usage Information describes the main types of PL/SQL
program units: packages, package bodies, and subprograms.
You can use PL/SQL to develop packages and stored (standalone) subprograms. Both
packages and stored subprograms are saved and stored in the database and can be
used as building blocks for applications.
Subprograms and Packages: Usage Information 8-1
Overview of Packages and Subprograms
Stored Subprograms
Packages
See Also: PL/SQL User's Guide and Reference to learn about PL/SQL
code and program units.
8.1.1 Stored Subprograms

Subprograms, which are either functions or procedures, can be compiled and stored in
an Oracle database, ready to be executed. Once compiled, it is a schema object known
as a stored procedure or stored function, which can be referenced by any number of
applications connected to that database.
The SQL CREATE PROCEDURE statement is used to create stored procedures that are
stored in the database. The SQL CREATE FUNCTION statement is used to create stored
functions that are stored in an Oracle database.
See Also:
Oracle Database SQL Reference for information on CREATE

PROCEDURE.
Oracle Database SQL Reference for information on CREATE
FUNCTION.
Subprograms are stored in a compact compiled form. When called, they are loaded
and processed immediately. Subprograms take advantage of shared memory, so that
only one copy of a subprogram is loaded into memory for execution by multiple users.
See Also: Oracle Database Express Edition 2 Day DBA Guide for
information on managing memory with Oracle Database
Stored subprograms defined within a package are known as packaged subprograms.

Those defined independently are called stored or standalone subprograms.
Subprograms nested inside other subprograms or within a PL/SQL block are known
as local subprograms, which cannot be referenced by other applications and exist only
inside the enclosing block.
Stored subprograms are the key to modular, reusable PL/SQL code. Wherever you
might use a JAR file in Java, a module in Perl, a shared library in C++, or a DLL in
Visual Basic, you should use PL/SQL stored procedures, stored functions, and
packages.
You can call stored subprograms from a database trigger, another stored subprogram,
or interactively from SQL*Plus. You can also configure a web server so that the HTML
for a web page is generated by a stored subprogram, making it simple to provide a
web interface for data entry and report generation.
8.1.2 Packages
A package is a schema object that groups logically related PL/SQL types, variables,
and subprograms. Packages usually have two parts, a specification (spec) and a body;
sometimes the body is unnecessary. The specification is the interface to the package. It
declares the types, variables, constants, exceptions, cursors, and subprograms that can
be referenced from outside the package. The body defines the queries for the cursors
and the code for the subprograms.
Managing Packages
You can think of the spec as an interface and of the body as a black box. You can
debug, enhance, or replace a package body without changing the package spec.
The SQL CREATE PACKAGE statement is used to create package specification (specs).
The CREATE PACKAGE BODY statement is used to define the package body.
See Also:
Oracle Database SQL Reference for information on the CREATE

PACKAGE SQL statement.
PACKAGE BODY SQL statement.
The spec holds public declarations, which are visible to stored procedures and other
code outside the package. You must declare subprograms at the end of the spec after
all other items (except pragmas that name a specific function; such pragmas must
follow the function spec).
The body holds implementation details and private declarations, which are hidden
from code outside the package. Following the declarative part of the package body is
the optional initialization part, which holds statements that initialize package variables
and do any other one-time setup steps.
8.2 Managing Subprograms

Subprograms do not have to belong to a package. Program units that are created
outside of a package are called stored or standalone subprograms. Stored subprograms
can be either functions or procedures. These subprograms are stored in the database
and can be reused by multiple applications. Both procedures and functions can accept
parameters when they are executed (called). To execute a stored subprogram, you only
need to include its object name.
A PL/SQL procedure is a subprogram that performs a specific action. You specify the
name of the procedure, its parameters, its local variables, and the BEGIN-END block
that contains its code and handles any exceptions. A function is a subprogram that
computes a value. Functions and procedures are structured alike, except that functions
return a value. For information on subprograms in PL/SQL blocks, see Using Local
PL/SQL Subprograms in PL/SQL Blocks.
8.3 Managing Packages

With PL/SQL, you can break an application down into manageable, well-defined
modules. Using PL/SQL code, you can write program units that are stored as database
objects that can be reused. These objects include packages, subprograms, and triggers.
Subprograms and packages are discussed in this topic; triggers are discussed in
Triggers: Usage Information.
When writing packages, keep them general so they can be reused in future
applications. Become familiar with the Oracle-supplied packages, and avoid writing
packages that duplicate features already provided by Oracle.
Design and define package specs before the package bodies. Place in a spec only those
things that must be visible to calling programs. That way, other developers cannot
build unsafe dependencies on your implementation details.
To reduce the need for recompiling when code is changed, place as few items as
possible in a package spec. Changes to a package body do not require recompiling
Managing Packages
calling procedures. Changes to a package spec require Oracle to recompile every

stored subprogram that references the package.
8.3.1 Calling Subprograms in Packages

Packages are stored in the database, where they can be shared by many applications.
Calling a packaged subprogram for the first time loads the whole package and caches
it in memory, saving on disk I/O for subsequent calls. Thus, packages enhance reuse
and improve performance in a multiuser, multi-application environment.
If a subprogram does not take any parameters, you can include an empty set of
parentheses or omit the parentheses, both in PL/SQL and in functions called from SQL
queries. For calls to a method that takes no parameters, an empty set of parentheses is
optional within PL/SQL scopes but required within SQL scopes.
8.3.2 Accessing Variables in Packages

You can create a package specification that is designated only to supply common
variables to other packages or subprograms. With the variables in one package, they
can be easily maintained for all subprograms that use the variables, rather than
maintaining the variables in all the individual subprograms. These common variables
are typically used in multiple subprograms, such as a sales tax rate.
In Example 81, the variables my_pi and my_e can be used by any subprogram. If you
change the value of my_pi or my_e, then all subprograms that use the variable get the
new value without having to change anything in those individual subprograms.
Note that you need to use of the package name as a prefix to the variable name, such
as my_pkg.my_pi.
Example 81 Using Variables in Packages
CREATE PACKAGE
my_pi
my_e
my_sales_tax
END my_pkg;
/
my_pkg
NUMBER
NUMBER
NUMBER
AS
:= 3.14016408289008292431940027343666863227;
:= 2.71828182845904523536028747135266249775;
:= 0.0825
CREATE PROCEDURE circle_area(radius NUMBER) IS

my_area NUMBER;
my_datatype VARCHAR2(30);
BEGIN
my_area := my_pkg.my_pi * radius;
DBMS_OUTPUT.PUT_LINE('Radius: ' || TO_CHAR(radius)
|| ' Area: ' || TO_CHAR(my_area) );
END;
/
-- call the circle_area procedure with radius equal to 3
CALL circle_area(3);
-- call the circle_area procedure with radius equal to 4
BEGIN
circle_area(3);
END;
/
-- cleanup: drop package and procedure
DROP PROCEDURE circle_area;
DROP PACKAGE my_pkg;
8.4 Oracle Product-Specific Packages

Oracle and various Oracle tools are supplied with product-specific packages that
define application programming interfaces (APIs) you can call from PL/SQL, SQL,
Java, or other programming environments. This topic includes a summary of two
widely used packages and a list of the most common packages with a brief
description.
See Also:
PL/SQL Packages and Types Reference for information on and usage

of product-specific packages.
About the DBMS_OUTPUT Package

Package DBMS_OUTPUT enables you to display output from PL/SQL blocks,
subprograms, packages, and triggers. The package is especially useful for displaying
PL/SQL debugging information. The procedure PUT_LINE outputs information to a
buffer that can be read by another trigger, procedure, or package. You display the
information by calling the procedure GET_LINE or by setting SERVEROUTPUT ON in
SQL*Plus. See Inputting and Outputting Data with PL/SQL.
Example 82 shows how to display output from a PL/SQL block.
Example 82 Using PUT_LINE in the DBMS_OUTPUT Package
-- set server output to ON to display output from DBMS_OUTPUT
SET SERVEROUTPUT ON
BEGIN
DBMS_OUTPUT.PUT_LINE('These are the tables that ' || USER || ' owns:');
FOR item IN (SELECT table_name FROM user_tables)
LOOP
DBMS_OUTPUT.PUT_LINE(item.table_name);
END LOOP;
END;
/
About the UTL_FILE Package

Package UTL_FILE lets PL/SQL programs read and write operating system (OS) text
files. It provides a restricted version of standard OS stream file I/O, including open,
put, get, and close operations.
When you want to read or write a text file, you call the function FOPEN, which returns
a file handle for use in subsequent procedure calls. For example, the procedure PUT_
LINE writes a text string and line terminator to an open file, and the procedure GET_
LINE reads a line of text from an open file into an output buffer.
Common Oracle Supplied Packages
Table 81 provides a list of the common PL/SQL packages included with Oracle
Database.
Table 81
Summary of Oracle Supplied PL/SQL Packages
Package Name
Description
DBMS_ALERT
Provides support for the asynchronous notification of

database events.
DBMS_APPLICATION_INFO
Lets you register an application name with the database

for auditing or performance tracking purposes.
Table 81 (Cont.) Summary of Oracle Supplied PL/SQL Packages

Package Name
Description
DBMS_AQ
Lets you add a message (of a predefined object type)

onto a queue or to dequeue a message.
DBMS_AQADM
Lets you perform administrative functions on a queue or

queue table for messages of a predefined object type.
DBMS_AQELM
Provides procedures to manage the configuration of

Advanced Queuing asynchronous notification by e-mail
and HTTP.
DBMS_AQIN
Plays a part in providing secure access to the Oracle JMS

interfaces.
DBMS_CHANGE_NOTIFICATION
Is part of a set of features that clients use to receive

notifications when result sets of a query have changed.
The package contains interfaces that can be used by
mid-tier clients to register objects and specify delivery
mechanisms.
DBMS_CRYPTO
Lets you encrypt and decrypt stored data, can be used in

conjunction with PL/SQL programs running network
communications, and supports encryption and hashing
algorithms.
DBMS_DATAPUMP
Lets you move all, or part of, a database between

databases, including both data and metadata.
DBMS_DB_VERSION
Specifies the Oracle version numbers and other

information useful for simple conditional compilation
selections based on Oracle versions.
DBMS_DDL
Provides access to some SQL DDL statements from

stored procedures, and provides special administration
operations not available as DDLs.
DBMS_DEBUG
Implements server-side debuggers and provides a way

to debug server-side PL/SQL program units.
DBMS_DESCRIBE
Describes the arguments of a stored procedure with full

name translation and security checking.
DBMS_EPG
Implements the embedded PL/SQL gateway that

enables a web browser to invoke a PL/SQL stored
procedure through an HTTP listener.
DBMS_ERRLOG
Provides a procedure that enables you to create an error

logging table so that DML operations can continue after
encountering errors rather than abort and roll back.
DMBS_FILE_TRANSFER
Lets you copy a binary file within a database or to

transfer a binary file between databases.
DMBS_FLASHBACK
Lets you flash back to a version of the database at a

specified wall-clock time or a specified system change
number (SCN).
DBMS_JOB
Lets you schedule administrative procedures that you

want performed at periodic intervals; it is also the
interface for the job queue.
DBMS_LOB
Provides general purpose routines for operations on

Oracle Large Object (LOBs) data types - BLOB, CLOB
(read/write), and BFILEs (read-only).
DBMS_LOCK
Lets you request, convert and release locks through

Oracle Lock Management services.

Package Name
Description
DBMS_METADATA
Lets callers easily retrieve complete database object

definitions (metadata) from the dictionary.
DBMS_OBFUSCATION_TOOLKIT
Provides procedures for Data Encryption Standards.
DBMS_OUTPUT
Accumulates information in a buffer so that it can be

retrieved later.
DBMS_PIPE
Provides a DBMS pipe service which enables messages

to be sent between sessions.
DBMS_RANDOM
Provides a built-in random number generator.
DBMS_RESUMABLE
Lets you suspend large operations that run out of space

or reach space limits after executing for a long time, fix
the problem, and make the statement resume execution.
DBMS_ROWID
Provides procedures to create rowids and to interpret

their contents.
DBMS_SCHEDULER
Provides a collection of scheduling functions that are

callable from any PL/SQL program.
DBMS_SERVER_ALERT
Lets you issue alerts when some threshold has been

violated.
DBMS_SESSION
Provides access to SQL ALTER SESSION statements,

and other session information, from stored procedures.
DBMS_SQL
Lets you use dynamic SQL to access the database.
DBMS_TDB
Reports whether a database can be transported between

platforms using the RMAN CONVERT DATABASE
command. It verifies that databases on the current host
platform are of the same endian format as the destination
platform, and that the state of the current database does
not prevent transport of the database.
DBMS_TTS
Checks if the transportable set is self-contained.
DBMS_TYPES
Consists of constants, which represent the built-in and

user-defined types.
DBMS_UTILITY
Provides various utility routines.
DBMS_WARNING
Provides the interface to query, modify and delete

current system or session settings.
DBMS_XDB
Describes Resource Management and Access Control

APIs for PL/SQL
DBMS_XDB_VERSION
Describes versioning APIs
DBMS_XDBT
Describes how an administrator can create a ConText

index on the XML DB hierarchy and configure it for
automatic maintenance
DBMS_XDBZ
Controls the Oracle XML DB repository security, which is

based on Access Control Lists (ACLs).
DBMS_XMLDOM
Explains access to XMLType objects
DBMS_XMLGEN
Converts the results of a SQL query to a canonical XML

format.
DBMS_XMLPARSER
Explains access to the contents and structure of XML

documents.
DMBS_XMLQUERY
Provides database-to-XMLType functionality.

Package Name
Description
DBMS_XMLSAVE
Provides XML-to-database-type functionality.
DBMS_XMLSCHEMA
Explains procedures to register and delete XML schemas.
DBMS_XMLSTORE
Provides the ability to store XML data in relational

tables.
DBMS_XPLAN
Describes how to format the output of the EXPLAIN

PLAN command.
DBMS_XSLPROCESSOR
Explains access to the contents and structure of XML

documents.
HTF
Hypertext functions generate HTML tags.
HTMLDB_APPLICATION
Enables users to take advantage of global variables
HTMLDB_CUSTOM_AUTH
Enables users to create form elements dynamically based

on a SQL query instead of creating individual items page
by page.
HTMLDB_ITEM
Enables users to create form elements dynamically based

on a SQL query instead of creating individual items page
by page.
HTMLDB_UTIL
Provides utilities for getting and setting session state,

getting files, checking authorizations for users, resetting
different states for users, and also getting and setting
preferences for users.
HTP
Hypertext procedures generate HTML tags.
OWA_CACHE
Provides an interface that enables the PL/SQL Gateway

cache to improve the performance of PL/SQL web
applications.
OWA_COOKIE
Provides an interface for sending and retrieving HTTP

cookies from the client's browser.
OWA_CUSTOM
Provides a Global PLSQL Agent Authorization callback

function
OWA_IMAGE
Provides an interface to access the coordinates where a

user clicked on an image.
OWA_OPT_LOCK
Contains subprograms that impose optimistic locking

strategies so as to prevent lost updates.
OWA_PATTERN
Provides an interface to locate text patterns within

strings and replace the matched string with another
string.
OWA_SEC
Provides an interface for custom authentication.
OWA_TEXT
Contains subprograms used by OWA_PATTERN for

manipulating strings. They are externalized so you can
use them directly.
OWA_UTIL
Contains utility subprograms for performing operations

such as getting the value of CGI environment variables,
printing the data that is returned to the client, and
printing the results of a query in an HTML table.
UTL_COLL
Enables PL/SQL programs to use collection locators to

query and update.
UTL_COMPRESS
Provides a set of data compression utilities.
UTL_DBWS
Provides database web services.

Package Name
Description
UTL_ENCODE
Provides functions that encode RAW data into a

standard encoded format so that the data can be
transported between hosts.
UTL_FILE
Enables your PL/SQL programs to read and write

operating system text files and provides a restricted
version of standard operating system stream file I/O.
UTL_HTTP
Enables HTTP callouts from PL/SQL and SQL to access

data on the Internet or to call Oracle Web Server
Cartridges.
UTL_I18N
Provides a set of services (Oracle Globalization Service)

that help developers build multilingual applications.
UTL_INADDR
Provides a procedure to support internet addressing.
UTL_LMS
Retrieves and formats error messages in different

languages.
UTL_MAIL
A utility for managing email which includes commonly

used email features, such as attachments, CC, BCC, and
return receipt.
UTL_RAW
Provides SQL functions for RAW data types that concat,

substr to and from RAWS.
UTL_RECOMP
Recompiles invalid PL/SQL modules, Java classes,

indextypes and operators in a database, either
sequentially or in parallel.
UTL_REF
Enables a PL/SQL program to access an object by

providing a reference to the object.
UTL_SMTP
Provides PL/SQL functionality to send emails.
UTL_TCP
Provides PL/SQL functionality to support simple

TCP/IP-based communications between servers and the
outside world.
UTL_URL
Provides escape and unescape mechanisms for URL

characters.
9
This topic discusses the use of database triggers with Oracle Express. Triggers are
database objects that can be created with PL/SQL code. This topic includes the
following topics:
Overview of Triggers
Designing Triggers
See Also:
Oracle Database Concepts for information on triggers.

information on triggers.
TRIGGER SQL statement.
9.1 Overview of Triggers

A database trigger is a stored subprogram associated with a database table, view, or
event. The trigger can be called once, when some event occurs, or many times, once for
each row affected by an INSERT, UPDATE, or DELETE statement. The trigger can be
called after the event, to record it or take some follow-up action. Or, the trigger can be
called before the event to prevent erroneous operations or fix new data so that it
conforms to business rules. The executable part of a trigger can contain procedural
statements as well as SQL data manipulation statements.
Triggers are created using the SQL CREATE TRIGGER statement. The CREATE (or
CREATE OR REPLACE) statement fails if any errors exist in the PL/SQL block.
Types of Triggers
Naming Triggers
When Is the Trigger Fired?
Controlling When a Trigger Is Fired
Accessing Column Values in Row Triggers
Detecting the DML Operation That Fired a Trigger
Enabled and Disabled Trigger Modes
Error Conditions and Exceptions in the Trigger Body

Oracle Database SQL Reference for information on trigger
creation syntax
See Also:
Triggers: Usage Information 9-1
9.1.1 Types of Triggers

A trigger is either a stored PL/SQL block or a PL/SQL, or C procedure associated with
a table, view, schema, or the database itself. Oracle automatically executes a trigger
when a specified event takes place, which usually is a DML statement being issued
against the table.
You can create triggers to be fired on any of the following:
DML statements (DELETE, INSERT, UPDATE)
DDL statements (CREATE, ALTER, DROP)
Database operations (LOGON, LOGOFF)
9.1.2 Naming Triggers

Trigger names must be unique with respect to other triggers in the same schema.
Trigger names do not need to be unique with respect to other schema objects, such as
tables, views, and procedures. For example, a table and a trigger can have the same
name; however, to avoid confusion, this is not recommended.
9.1.3 When Is the Trigger Fired?

A trigger is fired based on a triggering statement, which specifies:
The SQL statement or the system event, database event, or DDL event that fires
the trigger body. The options include DELETE, INSERT, and UPDATE. One, two, or
all three of these options can be included in the triggering statement specification.
The table, view, DATABASE, or SCHEMA associated with the trigger.
If a trigger contained the following statement:

AFTER DELETE OR INSERT OR UPDATE ON employees ...
then any of the following statements would fire the trigger:
DELETE
INSERT
INSERT
UPDATE
FROM employees WHERE ...;

INTO employees VALUES ( ... );
INTO employees SELECT ... FROM ... ;
employees SET ... ;
An UPDATE statement might include a list of columns. If a triggering statement

includes a column list, the trigger is fired only when one of the specified columns is
updated. If a triggering statement omits a column list, the trigger is fired when any
column of the associated table is updated. A column list cannot be specified for
INSERT or DELETE triggering statements.
9.1.4 Controlling When a Trigger Is Fired

There are several ways to control when a trigger is fired.
9.1.4.1 Firing Triggers With the BEORE and AFTER Options

The BEFORE or AFTER option in the CREATE TRIGGER statement specifies exactly
when to fire the trigger body in relation to the triggering statement that is being run. In
a CREATE TRIGGER statement, the BEFORE or AFTER option is specified just before the
triggering statement.
In general, you use BEFORE or AFTER triggers to achieve the following results:
Use a BEFORE row trigger to modify the row before the row data is written to disk.
Use an AFTER row trigger to obtain, and perform operations, using the row Id.
BEFORE row triggers are slightly more efficient than AFTER
row triggers. With AFTER row triggers, affected data blocks must be
read (logical read, not physical read) once for the trigger and then
again for the triggering statement. Alternatively, with BEFORE row
triggers, the data blocks must be read only once for both the triggering
statement and the trigger.
Note:
If an UPDATE or DELETE statement detects a conflict with a concurrent UPDATE, then

Oracle performs a transparent ROLLBACK and restarts the update. This can occur
many times before the statement completes successfully. Each time the statement is
restarted, the BEFORE statement trigger is fired again. The rollback does not undo
changes to any package variables referenced in the trigger. Your package should
include a counter variable to detect this situation.
9.1.4.2 Firing Triggers With the FOR EACH ROW Option

The FOR EACH ROW option determines whether the trigger is a row trigger or a
statement trigger. If you specify FOR EACH ROW, then the trigger fires once for each row
of the table that is affected by the triggering statement. These triggers are referred to as
row-level triggers.
The absence of the FOR EACH ROW option indicates that the trigger fires only once for
each applicable statement, but not separately for each row affected by the statement.
These triggers are referred to as statement-level triggers and are useful for performing
validation checks for the entire statement.
9.1.4.3 Firing Triggers Based on Conditions (WHEN Clause)

An optional trigger restriction can be included in the definition of a row trigger by
specifying a Boolean SQL expression in a WHEN clause.
If included, then the expression in the WHEN clause is evaluated for each row that the
trigger affects. If the expression evaluates to TRUE for a row, then the trigger body is
fired on behalf of that row.
The expression in a WHEN clause must be a SQL expression, and it cannot include a
subquery. You cannot use a PL/SQL expression (including user-defined functions) in
the WHEN clause. A WHEN clause cannot be included in the definition of a statement
trigger.
9.1.5 Accessing Column Values in Row Triggers

Within a trigger body of a row trigger, the PL/SQL code and SQL statements have
access to the old and new column values of the current row affected by the triggering
statement. Two correlation names exist for every column of the table being modified:
one for the old column value, and one for the new column value. These columns in the
table are identified by :OLD.colum_name and :NEW.column_name.
Depending on the type of triggering statement, certain correlation names might not
have any meaning.
A trigger fired by an INSERT statement has meaningful access to new column

values only. Because the row is being created by the INSERT, the old values are
null.
A trigger fired by an UPDATE statement has access to both old and new column
values for both BEFORE and AFTER row triggers.
A trigger fired by a DELETE statement has meaningful access to :OLD column
values only. Because the row no longer exists after the row is deleted, the :new
values are NULL and cannot be modified.
Old and new values are available in both BEFORE and AFTER row triggers. A new
column value can be assigned in a BEFORE row trigger, but not in an AFTER row
trigger (because the triggering statement takes effect before an AFTER row trigger is
fired). If a BEFORE row trigger changes the value of NEW.column, then an AFTER row
trigger fired by the same statement sees the change assigned by the BEFORE row
trigger.
Correlation names can also be used in the Boolean expression of a WHEN clause. A
colon (:) must precede the OLD and NEW qualifiers when they are used in a trigger
body, but a colon is not allowed when using the qualifiers in the WHEN clause.
9.1.6 Detecting the DML Operation That Fired a Trigger

If more than one type of DML operation can fire a trigger, such as ON INSERT OR
UPDATE, the trigger body can use the conditional predicates INSERTING, DELETING,
and UPDATING to check which type of statement fire the trigger.
Within the code of the trigger body, you can execute blocks of code depending on the
kind of DML operation fired the trigger.
In an UPDATE trigger, a column name can be specified with an UPDATING conditional
predicate to determine if the named column is being updated. For example, assume a
trigger is defined as the following:
CREATE OR REPLACE TRIGGER ...
... UPDATE OF salary ON employees ...
BEGIN
... IF UPDATING ('salary') THEN ... END IF;
...
The code in the THEN clause runs only if the triggering UPDATE statement updates the
salary column. This way, the trigger can minimize its overhead when the column of
interest is not being changed.
9.1.7 Enabled and Disabled Trigger Modes

A trigger can be in enabled or disabled modes. You would disable a trigger if you did
not want the trigger to execute, perhaps during maintenance activities on the database.
Enabled. An enabled trigger executes its trigger body if a triggering statement is

entered and the trigger restriction (if any) evaluates to TRUE.
Disabled. A disabled trigger does not execute its trigger body, even if a triggering
statement is entered and the trigger restriction (if any) evaluates to TRUE.
9.1.8 Error Conditions and Exceptions in the Trigger Body

If a predefined or user-defined error condition or exception is raised during the
execution of a trigger body, then all effects of the trigger body, as well as the triggering
statement, are rolled back unless the error is trapped by an exception handler.
Therefore, a trigger body can prevent the execution of the triggering statement by
Designing Triggers
raising an exception. User-defined exceptions are commonly used in triggers that

enforce complex security authorizations or integrity constraints.
9.2 Designing Triggers

This topic discusses the design of triggers. It includes the following topics:
Guidelines For Triggers
Restrictions on Creating Triggers
Privileges Needed to Work with Triggers
9.2.1 Guidelines For Triggers

Use the following guidelines when designing your triggers:
Use triggers to guarantee that when a specific operation is performed, related

actions are performed.
Do not define triggers that duplicate features already built into Oracle Database.
For example, do not define triggers to reject bad data if you can do the same
checking through declarative integrity constraints.
Limit the size of triggers. If the logic for your trigger requires much more than 60
lines of PL/SQL code, it is better to include most of the code in a stored procedure
and call the procedure from the trigger. The size of the trigger cannot be more than
32K.
Use triggers only for centralized, global operations that should be fired for the
triggering statement, regardless of which user or database application issues the
statement.
Do not create recursive triggers. For example, creating an AFTER UPDATE
statement trigger on the employees table that itself issues an UPDATE statement
on employees, causes the trigger to fire recursively until it has run out of
memory.
Use triggers on DATABASE judiciously. They are executed for every user every
time the event occurs on which the trigger is created.
9.2.2 Restrictions on Creating Triggers

When creating triggers with PL/SQL code, there are some restrictions that are not
required for standard PL/SQL blocks. The following topics discuss these restrictions.
SQL Statements Allowed in Trigger Bodies

The body of a trigger can contain DML SQL statements. It can also contain SELECT
statements, but they must be SELECT... INTO... statements or the SELECT statement in
the definition of a cursor.
DDL statements are not allowed in the body of a trigger. Also, no transaction control
statements are allowed in a trigger. ROLLBACK, COMMIT, and SAVEPOINT cannot be
used.For system triggers, {CREATE/ALTER/DROP} TABLE statements and
ALTER...COMPILE are allowed.
Designing Triggers
A procedure called by a trigger cannot run the previous

transaction control statements, because the procedure runs within the
context of the trigger body.
Note:
Statements inside a trigger can reference remote schema objects. However, pay special
attention when calling remote procedures from within a local trigger. If a timestamp or
signature mismatch is found during execution of the trigger, then the remote
procedure is not run, and the trigger is invalidated.
System Trigger Restrictions

Only committed triggers are fired. For example, if you create a trigger that should be
fired after all CREATE events, then the trigger itself does not fire after the creation,
because the correct information about this trigger was not committed at the time when
the trigger on CREATE events was fired.
For example, if you execute the following SQL statement:
CREATE OR REPLACE TRIGGER my_trigger
AFTER CREATE ON DATABASE
BEGIN
NULL;
END;
Then, trigger my_trigger is not fired after the creation of my_trigger. Oracle
Database does not fire a trigger that is not committed.
9.2.3 Privileges Needed to Work with Triggers

To create a trigger in your schema, you must have the CREATE TRIGGER system
privilege, and either:
Own the table specified in the triggering statement, or
Have the ALTER privilege for the table in the triggering statement, or
Have the ALTER ANY TABLE system privilege
To create a trigger in another user's schema, or to reference a table in another schema

from a trigger in your schema, you must have the CREATE ANY TRIGGER system
privilege. With this privilege, the trigger can be created in any schema and can be
associated with any user's table. In addition, the user creating the trigger must also
have EXECUTE privilege on the referenced procedures, functions, or packages.
To create a trigger on DATABASE, you must have the ADMINISTER DATABASE
TRIGGER privilege. If this privilege is later revoked, then you can drop the trigger, but
not alter it.
The object privileges to the schema objects referenced in the trigger body must be
granted to the trigger owner explicitly (not through a role). The statements in the
trigger body operate under the privilege domain of the trigger owner, not the privilege
domain of the user issuing the triggering statement. This is similar to the privilege
model for stored procedures.
10
SQL*Plus is an interactive and batch command-line query tool that is installed with
Oracle Database. This topic includes the following topics:
Overview of SQL*Plus
Using SQL*Plus
See Also:
SQL*Plus User's Guide and Reference for complete information

about SQL*Plus
Oracle Database SQL Reference for information on using SQL
statements
10.1 Overview of SQL*Plus

SQL*Plus is a command-line tool for accessing Oracle Database. It enables you to enter
and execute SQL, PL/SQL, and SQL*Plus commands to:
Query, insert, and update data
Execute PL/SQL procedures
Examine table and object definitions
Develop and run batch scripts
Perform database administration
You can use SQL*Plus to generate reports interactively, to generate reports as batch
processes, and to output the results to text file, to screen, or to HTML file for browsing
on the Internet.
10.2 Using SQL*Plus

This topic describes SQL*Plus, Oracle's command line tool for executing SQL and
PL/SQL.
Starting and Exiting SQL*Plus
Displaying Help With SQL*Plus
Entering and Executing SQL Statements and Commands
SQL*Plus DESCRIBE Command
SQL*Plus SET Commands
SQL*Plus: Usage Information 10-1
Using SQL*Plus
Running Scripts From SQL*Plus
Spooling From SQL*Plus
Using Variables With SQL*Plus
10.2.1 Starting and Exiting SQL*Plus

To start SQL*Plus from the operating system command prompt, enter the following:
sqlplus
When prompted, enter the username and password of the user account (schema) that
you want to access. For example, enter HR for the username and your_hr_password
when prompted.
After you have started SQL*Plus, the SQL> prompt displays for you to type in SQL
statements, as follows:
SQL>
When you want to quit or exit SQL*Plus, type EXIT or QUIT at the SQL prompt, as
follows:
SQL> EXIT
10.2.2 Displaying Help With SQL*Plus

To display a list of help topics for SQL*Plus commands enter HELP INDEX at the SQL
prompt as follows:
SQL> HELP INDEX
From the list of SQL*Plus help topics, you can display help on an individual topic by
entering HELP with a topic name. For example the following displays help on the
SQL*Plus COLUMN command, which enables you to format column output:
SQL> HELP COLUMN
10.2.3 Entering and Executing SQL Statements and Commands

To enter and execute SQL statements or commands, type in the statement or command
at the SQL prompt. At the end of a SQL statement, put a semi-colon (;) and then press
the Enter key to execute the statement. For example:
SQL> SELECT * FROM employees;
If the statement does not fit on one line, type in the first line and press the Enter key.
Continue entering lines, terminating the last line with a semi-colon (;). For example:
SQL> SELECT employee_id, first_name, last_name
2 FROM employees
3 WHERE employee_id >= 105 AND employee_id <= 110;
The output from the previous SELECT statement would be similar to:
EMPLOYEE_ID
----------105
106
107
108
109
FIRST_NAME
-------------------David
Valli
Diana
Nancy
Daniel
LAST_NAME
----------------------Austin
Pataballa
Lorentz
Greenberg
Faviet
Using SQL*Plus
110 John
6 rows selected.
Chen
Note that a terminating semi-colon (;) is optional with SQL *Plus commands, but
required with SQL statements.
10.2.4 SQL*Plus DESCRIBE Command

SQL*Plus provides the DESCRIBE to display a description of a database object. For
example, the following displays the structure of the employees table. This
description is useful when constructing SQL statements that manipulate the
employees table.
SQL> DESCRIBE employees
Name
---------------------------------------EMPLOYEE_ID
FIRST_NAME
LAST_NAME
EMAIL
PHONE_NUMBER
HIRE_DATE
JOB_ID
SALARY
COMMISSION_PCT
MANAGER_ID
DEPARTMENT_ID
Null? Type
-------- -----------NOT NULL NUMBER(6)
VARCHAR2(20)
NOT NULL VARCHAR2(25)
VARCHAR2(20)
NOT NULL DATE
NUMBER(8,2)
NUMBER(2,2)
NUMBER(6)
NUMBER(4)
10.2.5 SQL*Plus SET Commands

The SQL*Plus SET commands can be used to specify various SQL*Plus settings, such
as the format of the output from SQL*Plus statements. For example, the following SET
commands specify the number of lines per page display and the number of characters
per line in the output:
SQL> SET PAGESIZE 200
SQL> SET LINESIZE 140
To enable output from PL/SQL blocks with DBMS_OUTPUT
To view all the settings, enter the following at the SQL prompt:
SQL> SHOW ALL
For information about the SQL*Plus SERVEROUTPUT setting to display output from a
PL/SQL program, see Inputting and Outputting Data with PL/SQL.
See Also:
SQL*Plus User's Guide and Reference for information setting up the

SQL*Plus environment with a login file
10.2.6 Running Scripts From SQL*Plus

You can use a text editor to create SQL*Plus script files containing SQL*Plus, SQL, and
PL/SQL statements. For consistency, use the .sql extension for the script file name.
Using SQL*Plus
A SQL script file is executed with a START or @ command. For example, on a Windows
environment you could execute a SQL script as follows:
SQL> @c:\my_scripts\my_sql_script.sql
A SQL script file could be executed on a Linux environment as follows:
SQL> START /home/cjones/my_scripts/my_sql_script.sql
You can use SET ECHO ON to cause a script to echo each statement that is executed. You
can use SET TERMOUT OFF to prevent the script output from displaying on the screen.
When running a script, you should include the full path name unless the script is
located in the directory where SQL*Plus was launched.
10.2.7 Spooling From SQL*Plus

The SPOOL command can be used to direct the output from SQL*Plus to a disk file,
which enables you to save the output for future review.
To start spooling the output to an operating system file, you can enter:
SQL> SPOOL my_log_file.log
If you want to append the output to an existing file:
SQL> SPOOL my_log_file.log APPEND
To stop spooling and close a file, enter the following:
SQL> SPOOL OFF
10.2.8 Using Variables With SQL*Plus

You can write queries that use variables to make your SELECT statements more
flexible. You can define the variable prior to running a SQL statement or you can
prompt for a variable value at the time that the SQL statement is run.
When using a variable in a SQL statement, the variable name must be begin with an
ampersand (&).
Prompting for a Variable
Defining a Variable Value for a Query
For information on using bind variables in PL/SQL code, see Using Bind Variables.
10.2.8.1 Prompting for a Variable

In Example 101, including the variable &emp_id causes the SQL statement to prompt
for a value when the statement is executed. You can then enter the employee_id that
you want to display, such as employee Id 125.
Example 101
Defining a Variable
-- prompt for employee_id in a query, you need to enter a valid Id such as 125
SELECT employee_id, last_name, job_id FROM employees WHERE employee_id = &emp_id;
When you run the previous SELECT statement, the output is similar to:
Enter value for emp_id: 125
...
EMPLOYEE_ID LAST_NAME
JOB_ID
Using SQL*Plus
----------- ------------------------- ---------125 Nayer

ST_CLERK
10.2.8.2 Defining a Variable Value for a Query

In Example 102, the variable &jobid is defined prior to running the SQL statement
and the defined value is substituted for the variable when the statement is executed.
Example 102
Prompting for a Variable
-- define a variable value for a query as follows

DEFINE jobid = "ST_CLERK"
-- run a query using the defined value for jobid (ST_CLERK)
SELECT employee_id, last_name FROM employees WHERE job_id = '&jobid';
Using SQL*Plus
11
This topic describes how to use Oracle's database access products with Unicode and
provides useful information for SQL and PL/SQL programming in a globalization
support environment. It includes the following topics:
Overview of Globalization Support
Setting up the Globalization Support Environment
SQL and PL/SQL Programming with Unicode
Locale-Dependent SQL Functions with Optional NLS Parameters

See Also:
Oracle Database Globalization Support Guide for a complete

discussion of globalization support with Oracle Database,
including setting up the globalization support environment.
Oracle Database Reference for information on initialization
parameters used for globalization support
Oracle Database SQL Reference for information on date and time
formats.
11.1 Overview of Globalization Support

Oracle's globalization support enables you to store, process, and retrieve data in native
languages. It ensures that database utilities, error messages, sort order, and date, time,
monetary, numeric, and calendar conventions automatically adapt to any native
language and locale.
Oracle's globalization support includes National Language Support (NLS) features.
National Language Support is the ability to choose a national language and store data
in a specific character set. Globalization support enables you to develop multilingual
applications and software products that can be accessed and run from anywhere in the
world simultaneously. An application can render content of the user interface and
process data in the native users' languages and locale preferences.
Note: The National Language Support Parameters report lists the
values of parameters for globalization support. For information about
this and other Raptor reports, see Reports.
Oracle's standard features include:
Language Support
Working in a Global Environment 11-1
Overview of Globalization Support
The database enables you to store, process, and retrieve data in native languages.
Through the use of Unicode databases and data types, the Oracle database
supports most contemporary languages.
See "Setting NLS Parameters".
Territory Support
The database supports cultural conventions that are specific to geographical
locations. The default local time format, date format, and numeric and monetary
conventions depend on the local territory setting.
See "Language and Territory Parameters".
Date and Time Formats

Different conventions for displaying the hour, day, month, and year can be
handled in local formats. Time zones and daylight saving support are also
available.
See "Date and Time Parameters".
Monetary and Numeric Formats

Currency, credit, debit symbols, and numbers can be represented in local formats.
See "Monetary Parameters" and "Numeric and List Parameters" on page 11-11.
Calendars Feature
Oracle supports seven different calendar systems in use around the world:
Gregorian, Japanese Imperial, ROC Official (Republic of China), Thai Buddha,
Persian, English Hijrah, and Arabic Hijrah.
See "Calendar Definitions".
Linguistic Sorting
Oracle provides linguistic definitions for culturally accurate sorting and case
conversion.
See "Linguistic Sorting and Searching".
Character Set Support

Oracle supports a large number of single-byte, multibyte, and fixed-width
encoding schemes that are based on national, international, and vendor-specific
standards.
Character Semantics
Oracle provides character semantics. It is useful for defining the storage
requirements for multibyte strings of varying widths in terms of characters instead
of bytes.
See "Length Semantics".
Unicode Support
Unicode is a universal encoded character set that enables you to store information
in any language, using a single character set. Oracle Database provides products
such as SQL and PL/SQL for inserting and retrieving Unicode data.
See "SQL and PL/SQL Programming with Unicode".
11.2 Setting up the Globalization Support Environment

This topic discusses how to set up a globalization support environment. It includes the
following topics:
Setting NLS Parameters
Choosing a Locale with the NLS_LANG Environment Variable
Language and Territory Parameters
Date and Time Parameters
Calendar Definitions
Numeric and List Parameters
Monetary Parameters
Linguistic Sorting and Searching
Length Semantics
11.2.1 Setting NLS Parameters

NLS (National Language Support) parameters determine the locale-specific behavior
on both the client and the server. NLS parameters can be specified several ways. In this
guide, altering parameters for the user session and overriding the parameters in SQL
functions are discussed. Both of these techniques accomplished through the use of SQL
statements.
You can alter the NLS parameters settings by:
Setting NLS parameters in an ALTER SESSION statement to override the default

values that are set for the session in the initialization parameter file, or that are set
by the client with environment variables. For example:
ALTER SESSION SET NLS_SORT = french;
Note that the changes that you make with ALTER SESSION apply only to the
current user session and are not present the next time you log in.
See Also:
"Setting NLS Parameters" in Oracle Database Globalization

Support Guide for details on setting the NLS parameters
Oracle Database SQL Reference for more information about the
ALTER SESSION statement
Oracle Database Administrator's Guide for information on the
initialization parameter file
Using NLS parameters within a SQL function to override the default values that
are set for the session in the initialization parameter file, set for the client with
environment variables, or set for the session by the ALTER SESSION statement.
For example:
TO_CHAR(hiredate,'DD/MON/YYYY','nls_date_language = FRENCH')
See Also:
"Setting NLS Parameters" in Oracle Database Globalization

Support Guide for details on setting the NLS parameters
Oracle Database SQL Reference for more information about SQL
functions, including the TO_CHAR function
Additional methods for setting the NLS parameters require that you shutdown and
restart the database. These techniques include the following:
Including parameters in the Oracle Database initialization parameter file to specify

the default session NLS environment on the server side. For example:
NLS_TERRITORY = "CZECH REPUBLIC"
See Also: Oracle Database installation guide for Linux or
Windows for information on setting globalization parameters and
environmental variables.
Using NLS environment variables on the client, which may be

platform-dependent, to specify locale-dependent behavior for the client and also
to override the default values set for the session in the initialization parameter file.
For example, on a Linux system:
% setenv NLS_SORT FRENCH
See Also: Oracle Database installation guide for Linux or
Windows for information on setting globalization parameters and
environmental variables.
11.2.2 Choosing a Locale with the NLS_LANG Environment Variable

A locale is a linguistic and cultural environment in which a system or program is
running. Setting the NLS_LANG environment parameter is the simplest way to specify
locale behavior for Oracle software. It sets the language and territory used by the client
application and the database server. It also sets the client's character set, which is the
character set for data entered or displayed by a client program.
The NLS_LANG parameter sets the language and territory environment used by both
the server session (for example, SQL command execution) and the client application
(for example, display formatting in Oracle tools).
You might want to modify the NLS environment dynamically during the session. To
do so, you can use the ALTER SESSION statement to change NLS_LANGUAGE, NLS_
TERRITORY, and other NLS parameters.
You cannot modify the setting for the client character set
with the ALTER SESSION statement.
Note:
The ALTER SESSION statement modifies only the session environment. The local
client NLS environment is not modified, unless the client explicitly retrieves the new
settings and modifies its local environment.
See Also:
Oracle Database installation guides for information on the

NLS_LANG environmental variable
Oracle Database SQL Reference for information on the ALTER
SESSION statement.
11.2.3 Language and Territory Parameters

Setting different NLS parameters for local territories allows the database session to use
different cultural settings. For example, you can set the euro (EUR) as the primary
currency and the Japanese yen (JPY) as the secondary currency for a given database
session even when the territory is defined as AMERICA.
This topic contains information about the following parameters:
NLS_LANGUAGE
NLS_TERRITORY
11.2.3.1 NLS_LANGUAGE
The NLS_LANGUAGE parameter can be set to any valid language name and the default
is derived from the NLS_LANG setting. NLS_LANGUAGE specifies the default
conventions for the following session characteristics:
Language for server messages

Language for day and month names and their abbreviations (specified in the SQL
functions TO_CHAR and TO_DATE)
Symbols for equivalents of AM, PM, AD, and BC.
Default sorting sequence for character data when ORDER BY is specified. (GROUP
BY uses a binary sort unless ORDER BY is specified.)
Example 111 and Example 112 show the results from setting NLS_LANGUAGE to
different values. In Example 111, the ALTER SESSION statement is issued to set NLS_
LANGUAGE to Italian.
Example 111
NLS_LANGUAGE=ITALIAN
ALTER SESSION SET NLS_LANGUAGE=Italian;

-- enter a SELECT to check the format of the output after the ALTER SESSION
SELECT last_name, hire_date, ROUND(salary/8,2) salary FROM employees
You should see results similar to the following:

LAST_NAME
------------------------Sciarra
Urman
Popp
HIRE_DATE
SALARY
--------- ---------30-SET-97
962.5
07-MAR-98
975
07-DIC-99
862.5
Note that the month name abbreviations are in Italian.

In Example 112, the ALTER SESSION statement is issued to change the language to
German.
Example 112
NLS_LANGUAGE=GERMAN
ALTER SESSION SET NLS_LANGUAGE=German;

SELECT last_name, hire_date, ROUND(salary/8,2) salary FROM employees

LAST_NAME
------------------------Sciarra
Urman
Popp
HIRE_DATE
SALARY
--------- ---------30-SEP-97
962.5
07-MRZ-98
975
07-DEZ-99
862.5
Note that the language of the month abbreviations has changed to German.
See Also:

supported languages in the Oracle Database.
Oracle Database Globalization Support Guide for more information
on supported languages.
11.2.3.2 NLS_TERRITORY
The NLS_TERRITORY parameter can be set to any valid territory name and the default
is derived from the NLS_LANG setting. NLS_TERRITORY specifies the conventions for
the following default date and numeric formatting characteristics:
Date format
Decimal character and group separator
Local currency symbol
ISO currency symbol
Dual currency symbol
The territory can be modified dynamically during the session by specifying the new
NLS_TERRITORY value in an ALTER SESSION statement. For example, to change the
territory to France during a session, issue the following ALTER SESSION statement:
ALTER SESSION SET NLS_TERRITORY = France;
Modifying NLS_TERRITORY resets all derived NLS session parameters to default
values for the new territory. Example 113 and Example 114 show behavior that
results from different settings of NLS_TERRITORY and NLS_LANGUAGE.
Example 113
NLS_LANGUAGE=AMERICAN, NLS_TERRITORY=AMERICA
-- set NLS_LANAGUAGE and NLS_TERRITORY

ALTER SESSION SET NLS_LANGUAGE = American NLS_TERRITORY = America;
-- enter the following SELECT to view the format of the output for currency
SELECT TO_CHAR(salary,'L99G999D99') salary FROM employees
When NLS_TERRITORY is set to AMERICA and NLS_LANGUAGE is set to AMERICAN,

results similar to the following should appear:
SALARY
-------------------$24,000.00
$17,000.00
$17,000.00
In Example 114 an ALTER SESSION statement is issued to change the territory to
Germany.
Example 114
NLS_LANGUAGE=AMERICAN, NLS_TERRITORY=GERMANY
-- set NLS_TERRITORY to Germany for this session

ALTER SESSION SET NLS_TERRITORY = Germany;
SELECT TO_CHAR(salary,'L99G999D99') salary FROM employees

SALARY
------------------24.000,00
17.000,00
17.000,00
Note that the currency symbol has changed from $ to . The numbers have not
changed because the underlying data is the same.
See Also:

supported territories in the Oracle Database.
on supported territories
11.2.4 Date and Time Parameters

Oracle enables you to control the display of date and time, allowing different
conventions for displaying the hour, day, month, and year to be handled in local
formats. For example, in the United Kingdom, the date is displayed using the
DD/MM/YYYY format, while China commonly uses the YYYY-MM-DD format.
Date Formats
Time Formats
11.2.4.1 Date Formats

Different date formats are shown in Table 111.
Table 111
Examples of Short Date Formats
Country
Description
Example
Estonia
dd.mm.yyyy
28.02.2005
Germany
dd.mm.rr
28.02.05
Table 111 (Cont.) Examples of Short Date Formats

Country
Description
Example
China
yyyy-mm-dd
2005-02-28
UK
dd/mm/yyyy
28/02/2005
US
mm/dd/yyyy
02/28/2005
This topic includes the following parameters:
NLS_DATE_FORMAT
NLS_DATE_LANGUAGE
11.2.4.1.1 NLS_DATE_FORMAT The NLS_DATE_FORMAT parameter defines the default

date format to use with the TO_CHAR and TO_DATE functions. The NLS_TERRITORY
parameter determines the default value of NLS_DATE_FORMAT. The value of NLS_
DATE_FORMAT can be any valid date format mask. For example:
NLS_DATE_FORMAT = "MM/DD/YYYY"
The Oracle default date format may not always corresponds to the cultural specific
convention used in a given territory. You can utilize the short date and long date
format in SQL, using the 'DS' and 'DL' format masks respectively, to obtain dates in
a more localized formats. The examples in this topic show the differences between
some of the date formats.
Example 115
Using the Default, Short, and Long Date Formats
-- Use an ALTER SESSION statement to change the territory to America,

-- and the language to American
ALTER SESSION SET NLS_TERRITORY = America NLS_LANGUAGE = American;
-- After the session is altered, select the dates with the format masks
SELECT hire_date, TO_CHAR(hire_date,'DS') "Short",
TO_CHAR(hire_date,'DL') "Long" FROM employees
The results of the query in Example 115 are similar to the following:
HIRE_DATE
--------30-SEP-97
07-MAR-98
07-DEC-99
Short
---------9/30/1997
3/7/1998
12/7/1999
Long
----------------------------Tuesday, September 30, 1997
Saturday, March 07, 1998
Tuesday, December 07, 1999
To add string literals to the date format, enclose the string literal with double quotes.
Note that when double quotes are included in the date format, the entire value must
be enclosed by single quotes. For example:
NLS_DATE_FORMAT = '"Date: "MM/DD/YYYY'
11.2.4.1.2 NLS_DATE_LANGUAGE The NLS_DATE_LANGUAGE parameter specifies the
language for the day and month names produced by the TO_CHAR and TO_DATE
functions. NLS_DATE_LANGUAGE overrides the language that is specified implicitly by
NLS_LANGUAGE. NLS_DATE_LANGUAGE has the same syntax as the NLS_LANGUAGE
parameter, and all supported languages are valid values.
NLS_DATE_LANGUAGE also determines the language used for:
Month and day abbreviations returned by the TO_CHAR and TO_DATE functions
Month and day abbreviations used by the default date format (NLS_DATE_
FORMAT)
Example 116 shows how to use NLS_DATE_LANGUAGE to set the date language to
French.
Example 116
NLS_DATE_LANGUAGE=FRENCH, Month and Day Names
-- set NLS_DATE_LANAGUAGE for this user session

ALTER SESSION SET NLS_DATE_LANGUAGE = FRENCH;
-- display the current system date
SELECT TO_CHAR(SYSDATE, 'Day:Dd Month yyyy') FROM DUAL;
You should see output similar to the following, depending on the current system date:
TO_CHAR(SYSDATE,'DAY:DDMON
-------------------------Jeudi
:06 Octobre
2005
The default date format uses the month abbreviations determined by NLS_DATE_
LANGUAGE. For example, if the default date format is DD-MON-YYYY and NLS_DATE_
LANGUAGE = FRENCH, then insert a date as follows:
INSERT INTO table_name VALUES ('12-Fvr.-1997');
Oracle Database SQL Reference for information on date
format models
See Also:
11.2.4.2 Time Formats

Different time formats are shown in Table 112.
Table 112
Examples of Time Formats
Country
Description
Example
Estonia
hh24:mi:ss
13:50:23
Germany
hh24:mi:ss
13:50:23
China
hh24:mi:ss
13:50:23
UK
hh24:mi:ss
13:50:23
US
hh:mi:ssxff am
1:50:23.555 PM
This topic contains information about the following parameters:
NLS_TIMESTAMP_FORMAT
NLS_TIMESTAMP_TZ_FORMAT
11.2.4.2.1 NLS_TIMESTAMP_FORMAT NLS_TIMESTAMP_FORMAT defines the default

date format for the TIMESTAMP and TIMESTAMP WITH LOCAL TIME ZONE data
types. The NLS_TERRITORY parameter determines the default value of NLS_
TIMESTAMP_FORMAT. The value of NLS_TIMESTAMP_FORMAT can be any valid
datetime format mask.
The following example shows a value for NLS_TIMESTAMP_FORMAT:
NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH:MI:SS.FF'
11.2.4.2.2 NLS_TIMESTAMP_TZ_FORMAT NLS_TIMESTAMP_TZ_FORMAT defines the

default date format for the TIMESTAMP and TIMESTAMP WITH LOCAL TIME ZONE
data types. It is used with the TO_CHAR and TO_TIMESTAMP_TZ functions. The NLS_
TERRITORY parameter determines the default value of NLS_TIMESTAMP_TZ_
FORMAT. The value of NLS_TIMESTAMP_TZ_FORMAT can be any valid datetime
format mask.
The format value must be surrounded by quotation marks. For example:
NLS_TIMESTAMP_TZ_FORMAT = 'YYYY-MM-DD HH:MI:SS.FF TZH:TZM'
In Example 117 the TO_TIMESTAMP_TZ function uses the format value that was
specified for NLS_TIMESTAMP_TZ_FORMAT.
Example 117
Setting NLS_TIMESTAMP_TZ_FORMAT
-- display August 20, 2005 using the format of NLS_TIMPSTAMP_TZ_FORMAT

SELECT TO_TIMESTAMP_TZ('2005-08-20, 05:00:00.55 America/Los_Angeles',
'yyyy-mm-dd hh:mi:ss.ff TZR') "TIMESTAMP_TZ Format" FROM DUAL;
You should see output similar to the following:

TIMESTAMP_TZ Format
-------------------------------------------------------20-AUG-05 05.00.00.550000000 AM AMERICA/LOS_ANGELES
11.2.5 Calendar Definitions

Calendar Formats
NLS_CALENDAR
11.2.5.1 Calendar Formats

The following calendar information is stored for each territory:
First Day of the Week on page 11-10
First Calendar Week of the Year on page 11-10
Number of Days and Months in a Year on page 11-11
First Year of Era on page 11-11
11.2.5.1.1 First Day of the Week Some cultures consider Sunday to be the first day of the
week. Others consider Monday to be the first day of the week. A German calendar
starts with Monday.
The first day of the week is determined by the NLS_TERRITORY parameter.
11.2.5.1.2 First Calendar Week of the Year Some countries use week numbers for
scheduling, planning, and bookkeeping. Oracle supports this convention. In the ISO
standard, the week number can be different from the week number of the calendar
year. For example, 1st Jan 1988 is in ISO week number 53 of 1987. An ISO week
always starts on a Monday and ends on a Sunday.
To support the ISO standard, Oracle provides the IW date format element. It returns
the ISO week number.
The first calendar week of the year is determined by the NLS_TERRITORY parameter.
11.2.5.1.3 Number of Days and Months in a Year Oracle supports six calendar systems in
addition to Gregorian, the default:
Japanese Imperialuses the same number of months and days as Gregorian, but
the year starts with the beginning of each Imperial Era
ROC Officialuses the same number of months and days as Gregorian, but the
year starts with the founding of the Republic of China
Persianhas 31 days for each of the first six months. The next five months have 30
days each. The last month has either 29 days or 30 days (leap year).
Thai Buddhauses a Buddhist calendar
Arabic Hijrahhas 12 months with 354 or 355 days
English Hijrahhas 12 months with 354 or 355 days
The calendar system is specified by the NLS_CALENDAR parameter.

11.2.5.1.4
First Year of Era The Islamic calendar starts from the year of the Hegira.
The Japanese Imperial calendar starts from the beginning of an Emperor's reign. For
example, 1998 is the tenth year of the Heisei era.
11.2.5.2 NLS_CALENDAR
Many different calendar systems are in use throughout the world. NLS_CALENDAR
specifies which calendar system Oracle uses. The default value is Gregorian. The
value can be any valid calendar format name.
NLS_CALENDAR can have one of the following values:
Arabic Hijrah
English Hijrah
Gregorian
Japanese Imperial
Persian
ROC Official (Republic of China)
Thai Buddha
In Example 118 NLS_CALENDAR is set to English Hijrah.

Example 118
NLS_CALENDAR='English Hijrah'
-- set NLS_CALENDAR with ALTER SESSION

ALTER SESSION SET NLS_CALENDAR='English Hijrah';
-- display the current system date
SELECT SYSDATE FROM DUAL;
You should see output similar to the following, depending on the current system date:
SYSDATE
-------------------24 Ramadan
1422
11.2.6 Numeric and List Parameters

Numeric Formats
NLS_NUMERIC_CHARACTERS
11.2.6.1 Numeric Formats

The database must know the number-formatting convention used in each session to
interpret numeric strings correctly. For example, the database needs to know whether
numbers are entered with a period or a comma as the decimal character (234.00 or
234,00). Similarly, applications must be able to display numeric information in the
format expected at the client site.
Examples of numeric formats are shown in Table 113.
Table 113
Examples of Numeric Formats
Country
Numeric Formats
Estonia
1 234 567,89
Germany
1.234.567,89
China
1,234,567.89
UK
1,234,567.89
US
1,234,567.89
Numeric formats are derived from the setting of the NLS_TERRITORY parameter, but
they can be overridden by the NLS_NUMERIC_CHARACTERS parameter.
11.2.6.2 NLS_NUMERIC_CHARACTERS
The NLS_NUMERIC_CHARACTERS parameter specifies the decimal character and
group separator. The group separator is the character that separates integer groups to
show thousands and millions, for example. The group separator is the character
returned by the G number format mask. The decimal character separates the integer
and decimal parts of a number. Setting NLS_NUMERIC_CHARACTERS overrides the
default values derived from the setting of NLS_TERRITORY. The value can be any two
valid numeric characters for the decimal character and group separator.
Any character can be the decimal character or group separator. The two characters
specified must be single-byte, and the characters must be different from each other.
The characters cannot be any numeric character or any of the following characters:
plus (+), hyphen (-), less than sign (<), greater than sign (>). Either character can be a
space.
To set the decimal character to a comma and the grouping separator to a period, define
NLS_NUMERIC_CHARACTERS as follows:
ALTER SESSION SET NLS_NUMERIC_CHARACTERS = ",.";
SQL statements can include numbers represented as numeric or text literals. Numeric
literals are not enclosed in quotes. They are part of the SQL language syntax and
always use a dot as the decimal character and never contain a group separator. Text
literals are enclosed in single quotes. They are implicitly or explicitly converted to
numbers, if required, according to the current NLS settings.
The following SELECT statement formats the number 4000 with the decimal character
and group separator specified in the ALTER SESSION statement:
ALTER SESSION SET NLS_NUMERIC_CHARACTERS = ",.";
SELECT TO_CHAR(4000, '9G999D99') FROM DUAL;

TO_CHAR(4
--------4.000,00
11.2.7 Monetary Parameters

Oracle enables you to define radix symbols and thousands separators by locales. For
example, in the US, the decimal point is a dot (.), while it is a comma (,) in France.
Because the amount $1,234 has different meanings in different countries, it is
important to display the amount appropriately by locale.
Currency Formats
NLS_CURRENCY
NLS_ISO_CURRENCY
NLS_DUAL_CURRENCY
11.2.7.1 Currency Formats

Different currency formats are used throughout the world. Some typical ones are
shown in Table 114.
Table 114
Currency Format Examples
Country
Example
Estonia
1 234,56 kr
Germany
1.234,56
China
1,234.56
UK
1,234.56
US
$1,234.56
11.2.7.2 NLS_CURRENCY
NLS_CURRENCY specifies the character string returned by the L number format mask,
the local currency symbol. Setting NLS_CURRENCY overrides the default setting
defined implicitly by NLS_TERRITORY. The value can be any valid currency symbol
string.
Example 119
Displaying the Local Currency Symbol
-- select and format the salary column from employees

SELECT TO_CHAR(salary, 'L099G999D99') "salary" FROM employees
WHERE salary > 11000;

SALARY
--------------------$024,000.00
$017,000.00
$017,000.00
$012,000.00
$014,000.00
$013,500.00
$012,000.00
$011,500.00
$013,000.00
$012,000.00
11.2.7.3 NLS_ISO_CURRENCY
NLS_ISO_CURRENCY specifies the character string returned by the C number format
mask, the ISO currency symbol. Setting NLS_ISO_CURRENCY overrides the default
value defined implicitly by NLS_TERRITORY. The value can be any valid string.
Local currency symbols can be ambiguous. For example, a dollar sign ($) can refer to
US dollars or Australian dollars. ISO specifications define unique currency symbols for
specific territories or countries. For example, the ISO currency symbol for the US
dollar is USD. The ISO currency symbol for the Australian dollar is AUD.
NLS_ISO_CURRENCY has the same syntax as the NLS_TERRITORY parameter, and all
supported territories are valid values.
To specify the ISO currency symbol for France, set NLS_ISO_CURRENCY as shown in
Example 1110.
Example 1110 Setting NLS_ISO_CURRENCY
-- set NLS_ISO_CURRENCY to France
ALTER SESSION SET NLS_ISO_CURRENCY = FRANCE;
-- display the salary of selected employees
SELECT TO_CHAR(salary, 'C099G999D99') "Salary" FROM employees
WHERE department_id = 60;

Salary
-------------------EUR009,000.00
EUR006,000.00
EUR004,800.00
EUR004,800.00
EUR004,200.00
11.2.7.4 NLS_DUAL_CURRENCY
Use NLS_DUAL_CURRENCY to override the default dual currency symbol defined
implicitly by NLS_TERRITORY. The value can be any valid symbol.
NLS_DUAL_CURRENCY was introduced to support the euro currency symbol during
the euro transition period.
11.2.8 Linguistic Sorting and Searching

Different languages have their own sorting rules. Some languages are collated
according to the letter sequence in the alphabet, some according to the number of
stroke counts in the letter, and some are ordered by the pronunciation of the words.
Treatment of letter accents also differs among languages. For example, in Danish, is
sorted after Z, while Y and are considered to be variants of the same letter.
You can define how to sort data by using linguistic sort parameters. The basic
linguistic definition treats strings as sequences of independent characters.
NLS_SORT
NLS_COMP
11.2.8.1 NLS_SORT
The NLS_SORT parameter specifies the collating sequence for ORDER BY queries. It
overrides the default NLS_SORT value that is derived from NLS_LANGUAGE. The value
of NLS_SORT can be BINARY or any valid linguistic sort name:
NLS_SORT = BINARY | sort_name
If the value is BINARY, then the collating sequence is based on the numeric code of the
characters in the underlying encoding scheme. Depending on the data type, this will
either be in the binary sequence order of the database character set or the national
character set. If the value is a named linguistic sort, sorting is based on the order of the
defined sort. Most, but not all, languages supported by the NLS_LANGUAGE parameter
also support a linguistic sort with the same name.
You can set the NLS_SORT parameter to change the linguistic sorting behavior of the
your SQL session. Spain traditionally treats ch, ll as well as as letters of their own,
ordered after c, l and n respectively. Example 1111 and Example 1112 illustrate the
effect of using a Spanish sort against the employee names Chen and Chung. In
Example 1111, the NLS_SORT parameter is set to BINARY.
In Example 1111, LIKE is used to specify the records to return with the query. For
information on LIKE, see Restricting Data Using the WHERE Clause.
Example 1111 Setting NLS_SORT to BINARY
-- set the NLS_SORT for this user session
ALTER SESSION SET NLS_SORT=binary;
-- select the last name of those employees whose last name begin with C
SELECT last_name FROM employees
WHERE last_name LIKE 'C%' ORDER BY last_name;
The output of Example 1111 appears:

LAST_NAME
-------------Cabrio
Cambrault
Cambrault
Chen
Chung
Colmenares
In Example 1112, the NLS_SORT parameter is set to SPANISH_M.
Example 1112 Setting NLS_SORT to Spanish
-- set the NLS_SORT for this user session
ALTER SESSION SET NLS_SORT=spanish_m;
WHERE last_name LIKE 'C%' ORDER BY last_name;

LAST_NAME
-------------Cabrio
Cambrault
Cambrault
Colmenares
Chen
Chung
Note that the order of last names in the output from the SELECT statement in
Example 1111 and Example 1112 is different.
See Also:

on supported linguistic sorts.
11.2.8.2 NLS_COMP
When using comparison operators, characters are compared according to their binary
codes in the designated encoding scheme. A character is greater than another if it has a
higher binary code. Because the binary sequence of characters may not match the
linguistic sequence for a particular language, such comparisons might not be
linguistically correct.
The value of the NLS_COMP parameter affects the comparison behavior of SQL
operations. The value can be BINARY (default) or LINGUISTIC. You can use NLS_
COMP to avoid the cumbersome process of using the NLSSORT function in SQL
statements when you want to perform a linguistic comparison instead of a binary
comparison. When NLS_COMP is set to LINGUISTIC, SQL operations perform a
linguistic comparison based on the value of NLS_SORT.
Example 1113 and Example 1114 illustrate the effect of performing a binary
comparison follow by a Spanish linguistic sensitive comparison against the employee
names. In Example 1113 the NLS_COMP parameter is set to BINARY while NLS_SORT
is set to Spanish.
Example 1113 Setting NLS_COMP to BINARY
-- set NLS_SORT and NLS_COMP for this user session
ALTER SESSION SET NLS_SORT=spanish_m NLS_COMP=binary;
WHERE last_name LIKE 'C%';

LAST_NAME
-------------Cabrio
Cambrault
Cambrault
Chen
Chung
Colmenares
In Example 1114 the NLS_COMP parameter is set to LINGUISTIC while NLS_SORT is
set to Spanish.
Example 1114 Setting NLS_COMP to BINARY
-- set NLS_SORT and NLS_COMP for this user session
ALTER SESSION SET NLS_SORT=spanish_m NLS_COMP=linguistic;
WHERE last_name LIKE 'C%';

LAST_NAME
-------------Cabrio
Cambrault
Cambrault
Colmenares
Note the difference in the output of Example 1113 and Example 1114. In Spanish ch
is treated as a separate character following c so ch is excluded when a Spanish
linguistic sensitive comparison is performed in Example 1114.
11.2.8.3 Case and Accent Insensitive Searching

Operations inside a database are sensitive to the case and the accents of the characters.
Sometimes you might need to perform case-insensitive or accent-insensitive
comparisons. Use the NLS_SORT session parameter to specify a case-insensitive or
accent insensitive sort.
To specify a case-insensitive or accent-insensitive sort:
Append _CI to an Oracle sort name for a case-insensitive sort. For example:
BINARY_CI: accent sensitive and case insensitive binary sort
GENERIC_M_CI: accent sensitive and case insensitive GENERIC_M sort
Append _AI to an Oracle sort name for an accent-insensitive and case-insensitive

sort. For example:
BINARY_AI: accent insensitive and case insensitive binary sort
FRENCH_M_AI: accent insensitive and case insensitive FRENCH_M sort
11.2.9 Length Semantics

In single-byte character sets, the number of bytes and the number of characters in a
string are the same. In multibyte character sets, a character or code point consists of
one or more bytes. Calculating the number of characters based on byte lengths can be
difficult in a variable-width character set. Calculating column lengths in bytes is called
byte semantics, while measuring column lengths in characters is called character
semantics.
Character semantics is useful for defining the storage requirements for multibyte
strings of varying widths. For example, in a Unicode database (AL32UTF8), suppose
that you need to define a VARCHAR2 column that can store up to five Chinese
characters together with five English characters. Using byte semantics, this column
requires 15 bytes for the Chinese characters, which are three bytes long, and 5 bytes for
the English characters, which are one byte long, for a total of 20 bytes. Using character
semantics, the column requires 10 characters.
The expressions in the following list use byte semantics. Note the BYTE qualifier in the
VARCHAR2 expression and the B suffix in the SQL function name.
VARCHAR2(20 BYTE)
SUBSTRB(string, 1, 20)
The expressions in the following list use character semantics. Note the CHAR qualifier
in the VARCHAR2 expression.
VARCHAR2(20 CHAR)
SUBSTR(string, 1, 20)
This topic includes the following topic:
NLS_LENGTH_SEMANTICS on page 11-18
11.2.9.1 NLS_LENGTH_SEMANTICS
The NLS_LENGTH_SEMANTICS parameter specifies BYTE (default) or CHAR semantics.
By default, the character data types CHAR and VARCHAR2 are specified in bytes, not
characters. Hence, the specification CHAR(20) in a table definition allows 20 bytes for
storing character data.
NLS_LENGTH_SEMANTICS enables you to create CHAR, VARCHAR2, and LONG columns
using either byte or character length semantics. NCHAR, NVARCHAR2, CLOB, and NCLOB
columns are always character-based. Existing columns are not affected.
Example 1115 shows an example of creating a table. When the database character set
is WE8MSWIN1252, the last_name column of the table can hold up to 10 Western
European characters, occupying a maximum of 10 bytes. When the database character
set is Unicode (AL32UTF8), last_name can still hold up to 10 Unicode characters
regardless of the language; however, it can occupy a maximum of 40 bytes.
Example 1115 Length Semantics and CREATE TABLE
CREATE TABLE temp_employees_table
( employee_id NUMBER(4), last_name VARCHAR2(10 CHAR), job_id VARCHAR2(9),
manager_id NUMBER(4), hire_date DATE, salary NUMBER(7,2),
department_id NUMBER(2)) ;
See Also:
Oracle Database Concepts for more information about length

semantics
11.3 SQL and PL/SQL Programming with Unicode

SQL is the fundamental language with which all programs and users access data in an
Oracle database either directly or indirectly. PL/SQL is a procedural language that
combines the data manipulating power of SQL with the data processing power of
procedural languages. Both SQL and PL/SQL can be embedded in other programming
languages.
Oracle Express provides products such as SQL and PL/SQL for inserting and
retrieving Unicode data. Data is transparently converted between the database and
client programs, which ensures that client programs are independent of the database
character set and national character set. In addition, client programs are sometimes
even independent of the character data type, such as NCHAR or CHAR, used in the
database.
The PL/SQL and SQL engines process PL/SQL programs and SQL statements on
behalf of client-side programs such as server-side PL/SQL stored procedures. They
allow PL/SQL programs to declare CHAR, VARCHAR2, NCHAR, and NVARCHAR2
variables and to access SQL CHAR and NCHAR data types in the database.
This topic describes Unicode-related features in SQL and PL/SQL that you can deploy
for multilingual applications. It includes the following topics:
Overview of Unicode
SQL NCHAR Data Types
Unicode String Literals

See Also:
Oracle Database SQL Reference for information on SQL
11.3.1 Overview of Unicode

Unicode is a universal encoded character set that enables you to store information in
any language, using a single character set. Unicode provides a unique code value for
every character, regardless of the platform, program, or language.
Unicode has the following advantages:
It simplifies character set conversion and linguistic sort functions.
It improves performance compared with native multibyte character sets.
It supports the Unicode data type based on the Unicode standard.
You can store Unicode characters in an Oracle database in two ways:
You can create a Unicode database that enables you to store UTF-8 encoded
characters as SQL CHAR data types.
You can support multilingual data in specific columns by using Unicode data
types. You can store Unicode characters into columns of the SQL NCHAR data types
regardless of how the database character set has been defined. The NCHAR data
type is an exclusively Unicode data type.
11.3.2 SQL NCHAR Data Types

There are three SQL NCHAR data types:
The NCHAR Data Type on page 11-20
The NVARCHAR2 Data Type on page 11-20
11.3.2.1 The NCHAR Data Type

When you define a table column or a PL/SQL variable as the NCHAR data type, the
length is always specified as the number of characters. For example, the following
statement creates a column with a maximum length of 30 characters:
CREATE TABLE table1 (column1 NCHAR(30));
The maximum number of bytes for the column is determined as follows:
maximum number of bytes =
(maximum number of characters) x (maximum number of bytes for each character)
For example, if the national character set is UTF8, then the maximum byte length is 30
characters times 3 bytes for each character, or 90 bytes.
The national character set, which is used for all NCHAR data types, is defined when the
database is created. The national character set can be either UTF8 or AL16UTF16. The
default is AL16UTF16.
The maximum column size allowed is 2000 characters when the national character set
is UTF8 and 1000 when it is AL16UTF16. The actual data is subject to the maximum
byte limit of 2000. The two size constraints must be satisfied at the same time. In
PL/SQL, the maximum length of NCHAR data is 32767 bytes. You can define an NCHAR
variable of up to 32767 characters, but the actual data cannot exceed 32767 bytes. If
you insert a value that is shorter than the column length, then Oracle pads the value
with blanks to whichever length is smaller: maximum character length or maximum
byte length.
UTF8 may affect performance because it is a variable-width
character set. Excessive blank padding of NCHAR fields decreases
performance. Consider using the NVARCHAR data type or changing
to the AL16UTF16 character set for the NCHAR data type.
Note:
11.3.2.2 The NVARCHAR2 Data Type

The NVARCHAR2 data type specifies a variable length character string that uses the
national character set. When you create a table with an NVARCHAR2 column, you
specify the maximum number of characters for the column. Lengths for NVARCHAR2
are always in units of characters, just as for NCHAR. Oracle subsequently stores each
value in the column exactly as you specify it, if the value does not exceed the column's
maximum length. Oracle does not pad the string value to the maximum length.
The maximum column size allowed is 4000 characters when the national character set
is UTF8 and 2000 when it is AL16UTF16. The maximum length of an NVARCHAR2
column in bytes is 4000. Both the byte limit and the character limit must be met, so the
maximum number of characters that is actually allowed in an NVARCHAR2 column is
the number of characters that can be written in 4000 bytes.
In PL/SQL, the maximum length for an NVARCHAR2 variable is 32767 bytes. You can
define NVARCHAR2 variables up to 32767 characters, but the actual data cannot exceed
32767 bytes.
The following statement creates a table with one NVARCHAR2 column whose
maximum length in characters is 2000 and maximum length in bytes is 4000.
CREATE TABLE table2 (column2 NVARCHAR2(2000));
11.3.3 Unicode String Literals

You can input Unicode string literals in SQL and PL/SQL as follows:
Put a prefix N before a string literal that is enclosed with single quote marks. This
explicitly indicates that the following string literal is an NCHAR string literal. For
example, N'rsum' is an NCHAR string literal. This has the same limitation as
enclosing the string literal with single quote marks, where the data can be lost
during the conversion to the server's database character set. To avoid the potential
loss of data, you can set the environment variable ORA_NCHAR_LITERAL_
REPLACE to true. This will transparently replace the N' internally and preserve
the text literal for SQL processing. By default, this environment variable is set to
false to maintain backward compatibility.
Use the NCHR(n) SQL function, which returns a unit of character code in the
national character set, which is AL16UTF16 or UTF8. The result of concatenating
several NCHR(n) functions is NVARCHAR2 data. In this way, you can bypass the
client and server character set conversions and create an NVARCHAR2 string
directly. For example, NCHR(32) represents a blank character.
Because NCHR(n) is associated with the national character set, portability of the
resulting value is limited to applications that run with the same national character
set. If this is a concern, then use the UNISTR function to remove portability
limitations.
Use the UNISTR('string') SQL function. UNISTR('string') converts a string to

the national character set. To ensure portability and to preserve data, include only
ASCII characters and Unicode encoding in the following form: \xxxx, where
xxxx is the hexadecimal value of a character code value in UTF-16 encoding
format. For example, UNISTR('G\0061ry') represents 'Gary'. The ASCII
characters are converted to the database character set and then to the national
character set. The Unicode encoding is converted directly to the national character
set.
The last two methods can be used to encode any Unicode string literals.
11.4 Locale-Dependent SQL Functions with Optional NLS Parameters

All SQL functions whose behavior depends on globalization support conventions
allow NLS parameters to be specified. These functions are:
TO_CHAR
TO_DATE
TO_NUMBER
NLS_UPPER
NLS_LOWER
NLS_INITCAP
NLSSORT
Explicitly specifying the optional NLS parameters for these functions enables the
functions to be evaluated independently of the session's NLS parameters. This feature
can be important for SQL statements that contain numbers and dates as string literals.
For example, the following query is evaluated correctly if the language specified for
dates is AMERICAN:
SELECT last_name FROM employees WHERE hire_date > '01-JAN-1999';
Such a query can be made independent of the current date language by using a
statement similar to the following:
WHERE hire_date > TO_DATE('01-JAN-1999','DD-MON-YYYY',
'NLS_DATE_LANGUAGE = AMERICAN');
In this way, SQL statements that are independent of the session language can be
defined where necessary. Such statements are necessary when string literals appear in
SQL statements in views, CHECK constraints, or triggers.
Only SQL statements that must be independent of the
session NLS parameter values should explicitly specify optional
NLS parameters in locale-dependent SQL functions. Using session
default values for NLS parameters in SQL functions usually results
in better performance.
Note:
All character functions support both single-byte and multibyte characters. Except
where explicitly stated, character functions operate character by character, rather than
byte by byte.
The rest of this topic includes the following topics:
Default Values for NLS Parameters in SQL Functions
Specifying NLS Parameters in SQL Functions
Unacceptable NLS Parameters in SQL Functions
11.4.1 Default Values for NLS Parameters in SQL Functions

When SQL functions evaluate views and triggers, default values from the current
session are used for the NLS function parameters. When SQL functions evaluate
CHECK constraints, they use the default values that were specified for the NLS
parameters when the database was created.
11.4.2 Specifying NLS Parameters in SQL Functions

NLS parameters are specified in SQL functions as 'parameter = value'. For example:
'NLS_DATE_LANGUAGE = AMERICAN'
The following NLS parameters can be specified in SQL functions:
NLS_DATE_LANGUAGE
NLS_NUMERIC_CHARACTERS
NLS_CURRENCY
NLS_ISO_CURRENCY
NLS_DUAL_CURRENCY
NLS_CALENDAR
NLS_SORT
Table 115 shows which NLS parameters are valid for specific SQL functions.
Table 115
SQL Functions and Their Valid NLS Parameters
SQL Function
Valid NLS Parameters
TO_DATE
NLS_DATE_LANGUAGE,
NLS_CALENDAR
Table 115 (Cont.) SQL Functions and Their Valid NLS Parameters
SQL Function
Valid NLS Parameters
TO_NUMBER
NLS_NUMERIC_CHARACTERS,
NLS_CURRENCY,
NLS_DUAL_CURRENCY,
NLS_ISO_CURRENCY,
TO_CHAR
NLS_DATE_LANGUAGE,
NLS_CURRENCY,
NLS_ISO_CURRENCY,
NLS_DUAL_CURRENCY,
NLS_CALENDAR
TO_NCHAR
NLS_DATE_LANGUAGE,
NLS_CURRENCY,
NLS_ISO_CURRENCY,
NLS_DUAL_CURRENCY,
NLS_CALENDAR
NLS_UPPER
NLS_SORT
NLS_LOWER
NLS_SORT
NLS_INITCAP
NLS_SORT
NLSSORT
NLS_SORT
Example 1116 illustrates how to use NLS parameters in SQL functions.

Example 1116 Using NLS Parameters in SQL Functions
SELECT TO_DATE('1-JAN-99', 'DD-MON-YY',
'NLS_DATE_LANGUAGE = American') "01/01/99" FROM DUAL;
SELECT TO_CHAR(hire_date, 'DD/MON/YYYY',
'NLS_DATE_LANGUAGE = French') "Hire Date" FROM employees;
SELECT TO_CHAR(SYSDATE, 'DD/MON/YYYY',
'NLS_DATE_LANGUAGE = ''Traditional Chinese'' ') "System Date" FROM DUAL;
SELECT TO_CHAR(13000, '99G999D99',
'NLS_NUMERIC_CHARACTERS = '',.''') "13K" FROM DUAL;
SELECT TO_CHAR(salary, '99G999D99L', 'NLS_NUMERIC_CHARACTERS = '',.''
NLS_CURRENCY = ''EUR''') salary FROM employees;
SELECT TO_CHAR(salary, '99G999D99C', 'NLS_NUMERIC_CHARACTERS = ''.,''
NLS_ISO_CURRENCY = Japan') salary FROM employees;
SELECT NLS_UPPER(last_name, 'NLS_SORT = Swiss') "Last Name" FROM employees;
ORDER BY NLSSORT(last_name, 'NLS_SORT = German');
In some languages, some lowercase characters correspond

to more than one uppercase character or vice versa. As a result, the
length of the output from the NLS_UPPER, NLS_LOWER, and NLS_
INITCAP functions can differ from the length of the input.
Note:
11.4.3 Unacceptable NLS Parameters in SQL Functions

The following NLS parameters are not accepted in SQL functions except for NLSSORT:
NLS_LANGUAGE
NLS_TERRITORY
NLS_DATE_FORMAT
NLS_DATE_FORMAT and NLS_TERRITORY_FORMAT are not accepted as parameters

because they can interfere with required format masks. A date format must always be
specified if an NLS parameter is in a TO_CHAR or TO_DATE function. As a result, NLS_
DATE_FORMAT and NLS_TERRITORY_FORMAT are not valid NLS parameters for the
TO_CHAR or TO_DATE functions. If you specify NLS_DATE_FORMAT or NLS_
TERRITORY_FORMAT in the TO_CHAR or TO_DATE function, then an error is returned.
NLS_LANGUAGE can interfere with the session value of NLS_DATE_LANGUAGE. If you
specify NLS_LANGUAGE in the TO_CHAR function, for example, then its value is
ignored if it differs from the session value of NLS_DATE_LANGUAGE.
Index
Symbols
:= assignment operator,
7-6
A
ACCESS_INTO_NULL exception, 7-22
AFTER triggers
correlation names and, 9-4
specifying, 9-2
aliases
tables, 6-6
ALTER INDEX statement, 6-16
ALTER TABLE statement, 6-16, 6-17
analyzing tables, 1-9
anonymous PL/SQL blocks, 7-2
apostrophes, 7-7
arrays
PL/SQL, 7-17
assignment operator, 7-6
assignments
IN OUT parameters, 7-15
associations
file types, 3-20
attributes
%ROWTYPE, 7-10
%TYPE, 7-11
B
BEFORE triggers
correlation names and,
specifying, 9-2
BEGIN
block structure, 7-3
BINARY_DOUBLE
data types, 5-5
BINARY_FLOAT
data types, 5-5
bind variables
for reports, 1-20
PL/SQL, 7-21
blocks
anonymous, 7-2
BEGIN, 7-3
DECLARE, 7-3
9-4
END, 7-3
EXCEPTION, 7-3
nesting, 7-1, 7-2
structure, 7-3
BODY
CREATE PACKAGE SQL statement, 8-3
with SQL CREATE PACKAGE statement, 8-3
Boolean
literals, 7-7
breakpoints
creating and editing, 3-23
C
C number format mask, 11-14
calendars
parameter, 11-10
CASE expressions
overview, 7-12
case sensitivity
identifier, 7-6
string literal, 7-7
CASE_NOT_FOUND exception, 7-22
century
date format masks, 5-7
character data
storing, 5-1
character literals, 7-7
quoting, 6-3
using in SQL statements, 6-3
character set
national, 11-20
character sets
national, 11-20
check constraints, 3-11, 4-5
how to use, 4-6
Check for Updates feature, 3-2
coalescing an index, 1-6
code fragments, 1-19
COLLECTION_IS_NULL exception, 7-22
collections
PL/SQL, 7-17
column alias
using with SELECT, 6-4
column constraints, 4-4
columns
Index-1
accessing in triggers, 9-3

data types, 4-2
decrypting, 1-10
encrypting, 1-9
listing in an UPDATE trigger, 9-4
unique key, 4-5
comments
in PL/SQL, 7-4
COMMIT statement, 6-8, 6-9
Compact option for shrinking a table, 1-9
comparison operators
BETWEEN, 6-4
equality, 6-4
IN, 6-4
LIKE, 6-4
NULL, 6-4
compiling
function, 1-6
procedure, 1-8
view, 1-10
composite keys
foreign, 4-6
conditional predicates
trigger bodies, 9-4
configuring file type associations, 3-20
connections
creating, editing, or selecting, 3-2
explanation, 1-11
CONSTANT
for declaring constants, 7-4
constants
declaring, 7-4
declaring in PL/SQL, 7-4
constraints
check, 3-11, 4-5
column, 4-4
disabled, 1-22
ensuring data integrity, 4-3
NOT NULL, 7-8
table-level, 4-4
types, 4-4
unique, 3-10
control structures
PL/SQL, 7-11
correlation names, 9-3
NEW, 9-3
OLD, 9-3
when preceded by a colon, 9-4
CREATE
with PROCEDURE statement, 8-2
CREATE FUNCTION statement, 8-2
CREATE INDEX statement, 6-16
CREATE PROCEDURE statement, 8-2
CREATE SEQUENCE statement, 6-17
CREATE statement
packages, 8-3
with FUNCTION, 8-2
CREATE SYNONYM statement, 6-18
CREATE TABLE statement, 6-15
CREATE TRIGGER statement, 9-1
Index-2
creating
functions, 8-2
packages, 8-3
procedures, 8-2
creating a constraint
using SQL statement, 6-16
creating a table
creating an index
SQL statement, 6-16
creating indexes for use with constraints, 4-7
currencies
formats, 11-13
CURSOR_ALREADY_OPEN exception, 7-22
cursors
definition, 7-17
explicit, 7-17
implicit, 7-17
customizing Raptor
setting preferences, 1-26
D
data
entering and modifying, 1-12
integrity checking on input, 5-3
data definition language (DDL)
SQL statements, 6-15
data integrity rules
as constraints, 4-4
data manipulation language
described, 6-7
data structures
PL/SQL, 7-17
data types
BINARY_DOUBLE, 5-5
BINARY_FLOAT, 5-5
CHAR, 5-1
character, 5-1
creating, 3-15
description, 4-2
floating-point number, 5-4
in table columns, 4-2
NCHAR, 5-1
NUMBER, 5-3
numeric, 5-2
NVARCHAR2, 5-1
overview, 5-1
VARCHAR2, 5-1
database connections
creating, editing, or selecting, 3-2
explanation, 1-11
database link
database objects, 1-5
managing, 4-1
naming, 4-1
database resident program units, 8-1
database triggers, 9-1
date and time data
storing, 5-5
date and time parameters, 11-7
DATE data type, 5-5
date formats, 11-7, 11-8
dates
ISO standard, 11-10
NLS_DATE_LANGUAGE parameter, 11-9
datetime
literals, 7-7
days
format element, 11-9
DBMS_OUTPUT
procedures for displaying output in PL/SQL, 7-9
DBMS_OUTPUT package
displaying output, 7-9
displaying output from PL/SQL, 8-5
using PUT_LINE to display output, 7-9
debugging PL/SQL function or procedure, 1-13
dialog box, 3-22
declarations
constants, 7-4
exceptions in PL/SQL, 7-23
PL/SQL %ROWTYPE and %TYPE, 7-10
PL/SQL subprograms, 7-15
using NOT NULL constraint, 7-8
declarative part
of PL/SQL block, 7-3
DECLARE
decryption
data in a table column, 1-10
DELETE statement, 6-7, 6-8
column values and triggers, 9-4
dependencies
schema objects
trigger management, 9-6
DESCRIBE command
SQL*Plus, 10-3
design considerations
Oracle Database, 4-1
dialog boxes and tabs, 3-1
disabled constraints, 1-22
disabled trigger
definition, 9-4
disabling
triggers, 9-4
displaying output
from PL/SQL, 7-9
setting SERVEROUTPUT, 7-9, 8-5
using DBMS_OUTPUT.PUT_LINE, 7-9
displaying PL/SQL output
with DBMS_OUTPUT, 7-9
distributed databases
triggers and, 9-6
dot notation, 7-11
DROP INDEX statement, 6-16
DROP SEQUENCE statement, 6-17
DROP SYNONYM statement, 6-18
DROP TABLE statement, 6-17
dropping
indexes, 4-10
dropping a sequence
dropping a synonym
dropping a table
DUAL
dummy table, 6-10
dummy table
DUAL, 6-10
DUP_VAL_ON_INDEX exception, 7-22
dynamic SQL, 7-19
E
enabled trigger
definition, 9-4
enabling
triggers, 9-4
encryption
data in a table column, 1-9
END
ensuring data integrity
with constraints, 4-3
entering data in tables, 1-12
error handling
PL/SQL, 7-21
EXCEPTION
exception handlers
PL/SQL, 7-21
exception-handling part
exceptions
advantages of PL/SQL, 7-23
during trigger execution, 9-4
list of predefined in PL/SQL, 7-22
predefined in PL/SQL, 7-21
scope rules in PL/SQL, 7-23
executable part
execution plan, 1-18
EXIT-WHEN statement
overview, 7-14
EXPLAIN PLAN
execution plan, 1-18
exporting
table data, 1-9, 3-20
extensions
Raptor, 1-30
F
FALSE value, 7-7
file I/O, 8-5
file types
associating with Raptor, 3-20
Index-3
floating-point number
data types, 5-4
floating-point numbers, 5-2
folders
for user-defined reports, 1-25, 3-16
FOR EACH ROW clause, 9-3
foreign key
referential integrity between tables, 4-6
foreign keys, 3-11
format elements
day, 11-9
month, 11-9
format masks, 11-12
TO_DATE function, 5-7
formats
currency, 11-13
date, 11-8
numeric, 11-12
time, 11-9
Freeze View
pinning an objects display, 1-3, 1-12
FROM clause, 3-18
FUNCTION
with CREATE statement, 8-2
functions
compiling, 1-6
creating, 8-2
debugging, 3-22
execute, 8-3
managing, 8-3
overview, 8-1
running, 3-22
SQL aggregate, 6-14
SQL arithmetic operators, 6-12
SQL character, 6-11
SQL date, 6-13
SQL numeric, 6-12
G
globalization support
altering NLS parameter settings, 11-3
calendar definitions, 11-10
date and time parameter settings, 11-7
default values for NLS parameters in SQL
functions, 11-22
features, 11-1
language and territory parameter settings, 11-5
linguistic sorting and searching, 11-14
locale, 11-4
monetary parameter settings, 11-13
National Language Support (NLS) features, 11-1
NLS_LANG parameter setting, 11-4
numeric and list parameter settings, 11-11
overview, 11-1
programming with unicode, 11-18
setting up the environment, 11-3
specifying values for NLS parameters in SQL
functions, 11-22
Index-4
unacceptable NLS parameters in SQL

functions, 11-24
GOTO statement
overview, 7-15
graphical user interface (GUI), 1-1
GROUP BY clause, 3-19
H
HAVING clause, 3-19
help
using the online help, 1-31
HELP command
SQL*Plus, 10-2
I
identifiers
maximum length, 7-6
IF-THEN-ELSE statement
overview, 7-11
indexes, 3-12
ascending, 4-7
choose the correct order of columns for
composites, 4-9
coalescing, 1-6
column, 4-7
concatenated, 4-7
creating for use with constraints, 4-7
descending, 4-7
drop if not required, 4-10
dropping, 4-10
explanation, 1-6
function-based, 4-7
guidelines, 4-8
limit the number, 4-9
making unusable, 1-6
managing, 4-6
normal type, 4-7
order of columns, 4-9
rebuilding, 1-6
single column, 4-7
types, 4-7
initialization
using DEFAULT, 7-8
INSERT statement, 6-7
integrity constraints
CHECK, 4-6
triggers vs., 9-5
INTERVAL DAY TO SECOND data type, 5-5
INTERVAL YEAR TO MONTH data type, 5-5
introduction, 1-1, 4-1, 5-1, 6-1, 7-1, 8-1, 9-1, 10-1, 11-1
INVALID_CURSOR exception, 7-22
INVALID_NUMBER exception, 7-22
ISO standard date format, 11-10
J
joins
displaying data from multiple tables with

SELECT, 6-6
K
keywords
use in PL/SQL, 7-6
L
language support, 11-2
length semantics, 11-17
linguistic sorts
parameters, 11-14
link
database, 3-4
list parameter, 11-11
literals
Boolean, 7-7
character, 7-7
datetime, 7-7
numeric, 7-7
string, 7-7
types of PL/SQL, 7-7
local subprograms, 8-2
locale
globalization support, 11-4
locking a table, 1-9
LOGIN_DENIED exception, 7-22
LOOP statement
overview, 7-13
lowercase characters in object names
quotation marks required, 3-1
M
managing database objects
overview, 4-1
managing indexes, 4-6
managing tables, 4-2
materialized view logs, 1-7
materialized views, 1-7
maximum size
identifier, 7-6
modifying a constraint
modifying a table
modifying an index
SQL statement, 6-16
modifying data in tables, 1-12
modularity, 8-3
monetary parameters, 11-13
months
format element, 11-9
moving a table to another tablespace, 1-9
multi-line comments, 7-4
N
national character literals
quoting, 6-3
national character set, 11-20
National Language Support (NLS)
features, 11-1
NCHAR data type, 5-1, 11-20
NCHR SQL function, 11-21
nested tables
PL/SQL, 7-17
nesting
block, 7-1, 7-2
NEW correlation name, 9-3
NLS parameters
default values in SQL functions, 11-22
settings, 11-3
specifying in SQL functions, 11-22
unacceptable in SQL functions, 11-24
NLS_CALENDAR parameter, 11-11
NLS_COMP parameter, 11-16
NLS_CURRENCY parameter, 11-13
NLS_DATE_FORMAT parameter, 5-7, 11-8
NLS_DATE_LANGUAGE parameter, 11-8
NLS_DUAL_CURRENCY parameter, 11-14
NLS_INITCAP SQL function, 11-21
NLS_ISO_CURRENCY parameter, 11-14
NLS_LANG parameter, 11-4
choosing a locale, 11-4
NLS_LANGUAGE parameter, 11-5
NLS_LOWER SQL function, 11-21
NLS_NUMERIC_CHARACTERS parameter, 11-12
NLS_SORT parameter, 11-15
NLS_TERRITORY parameter, 11-6
NLS_TIMESTAMP_FORMAT parameter
parameters
NLS_TIMESTAMP_FORMAT, 11-9, 11-10
NLS_UPPER SQL function, 11-21
NLSSORT SQL function, 11-21
NO_DATA_FOUND exception, 7-22
NOT NULL constraint
using in variable declaration, 7-8
NOT_LOGGED_ON exception, 7-22
NUMBER data type, 5-3
numeric data types, 5-2
numeric formats, 11-12
numeric literals, 7-7
numeric parameters, 11-11
NVARCHAR2 data type, 5-1, 11-20
O
objects
database, 1-5
OLD correlation name, 9-3
online help
using, 1-31
Oracle Database
design considerations, 4-1
ORDER BY clause, 3-19
overview, 1-1, 4-1, 5-1, 6-1, 7-1, 8-1, 9-1, 10-1, 11-1
Index-5
data types, 5-1

functions, 8-1
managing database objects, 4-1
packages, 8-1
PL/SQL, 7-1
procedures, 8-1
SQL, 6-1
SQL*Plus, 10-1
subprograms, 8-1
triggers, 9-1
P
PACKAGE
with SQL CREATE statement, 8-3
package
writing with PL/SQL, 8-3
PACKAGE BODY
with SQL CREATE statement, 8-3
packaged subprograms, 8-2
packages
accessing variables, 8-4
body, 8-2
creating, 8-3
debugging, 3-22
guidelines for writing, 8-3
hidden declarations, 8-3
overview, 8-1
overview of Oracle supplied, 8-5
product-specific, 8-5
running, 3-22
specification, 8-2
understanding, 8-2
variables, 8-4
visibility of contents, 8-3
parameters
calendar, 11-10
linguistic sorts, 11-14
monetary, 11-13
NLS_CALENDAR, 11-11
NLS_COMP, 11-16
NLS_CURRENCY, 11-13
NLS_DATE_FORMAT, 11-8
NLS_DATE_LANGUAGE, 11-8
NLS_DUAL_CURRENCY, 11-14
NLS_ISO_CURRENCY, 11-14
NLS_LANG, 11-4
NLS_LANGUAGE, 11-5
NLS_NUMERIC_CHARACTERS, 11-12
NLS_SORT, 11-15
NLS_TERRITORY, 11-6
numeric, 11-11
setting, 11-4
time and date, 11-7
time zone, 11-9, 11-10
performance
index column order, 4-9
pinning an objects display, 1-3, 1-12
Index-6
PL/SQL, 7-1
%ROWTYPE attribute, 7-10
%TYPE attribute, 7-10
anonymous blocks, 7-2
arrays, 7-17
assigning values with SELECT INTO, 7-9
assignment operator, 7-6
bind variables, 7-21
collections, 7-17
comments, 7-4
control structures, 7-11
cursor, 7-17
data structures, 7-17
declarations using DEFAULT, 7-8
declarations using NOT NULL, 7-8
declaring constants, 7-4
declaring variables, 7-4
DEFAULT keyword for assignments, 7-8
displaying output, 7-9, 8-5
entering and executing code, 7-2
error handling, 7-21
exception handling, 7-21
identifiers, 7-5
input data, 7-9
literals, 7-7
local subprograms, 7-15
nested tables, 7-17
output data, 7-9
overview of, 7-1
processing queries, 7-19
program units, 7-1
records, 7-18
SELECT INTO, 7-9
stored procedures, 7-2
trigger bodies, 9-3
using dynamic SQL, 7-19
using features, 7-2
variable assignments, 7-6
writing reusable code, 8-3
PL/SQL and SQL and Unicode, 11-19
PL/SQL subprograms
debugging, 3-22
breakpoints, 3-23
running, 3-22
preferences
customizing Raptor, 1-26
primary key, 3-10
for a table, 4-5
PRIMARY KEY constraints
multiple columns in, 4-5
UNIQUE key constraint vs., 4-5
private synonyms, 3-7
privileges
needed on triggers, 9-6
triggers, 9-6
PROCEDURE
with CREATE statement, 8-2
procedures, 7-2
called by triggers, 9-6
compiling, 1-8
creating, 8-2
execute, 8-3
managing, 8-3
overview, 8-1
program units, 7-1, 8-3
PROGRAM_ERROR exception, 7-22
pseudocolumns
ROWNUM, 6-10
SYSDATE, 6-10
USER, 6-10
public synonyms, 3-7
PUT_LINE
displaying output with, 7-9
Q
queries
in DML, 6-7
quotation marks
for name with lowercase characters, special
characters, or spaces, 3-1
quoting character literals, 6-3
R
raising exceptions
triggers, 9-4
Raptor preferences, 1-26
rebuilding an index, 1-6
recompiling
view, 1-10
records
definition, 7-10
PL/SQL, 7-18
Recycle bin, 1-8
report navigator, 1-20
reports, 1-20
bind variables for, 1-20
user-defined
explanation, 1-25
folders for, 1-25, 3-16
reserved words
syntactic meaning in PL/SQL, 7-6
restrictions
system triggers, 9-6
ROLLBACK statement, 6-8, 6-9
row triggers
defining, 9-3
timing, 9-2
UPDATE statements and, 9-4
ROWNUM
pseudocolumn, 6-10
ROWTYPE attribute
declaring, 7-10
ROWTYPE_MISMATCH exception, 7-22
running PL/SQL function or procedure, 1-13
dialog box, 3-22
S
scale
greater than precision, 5-3
schema objects, 1-5
description, 4-1
tables, 4-2
schemas
description, 4-1
scientific notation, 7-7
scope
exceptions in PL/SQL, 7-23
script runner, 1-17
scripts
running, 1-17
SELECT clause, 3-18
SELECT INTO
PL/SQL, 7-9
SELECT statements, 6-2
SELF_IS_NULL exception, 7-22
sequences
description, 4-10
managing, 4-10
SERVEROUTPUT
displaying output from PL/SQL, 7-9
setting ON to display output, 8-5
SET command
for SQL*Plus settings, 10-3
shrinking a table, 1-9
single-line comments, 7-4
snippets, 1-19
sorting
specifying nondefault linguistic sorts, 11-15,
11-16
source types
description, 8-1
managing, 8-1
spaces in object names
special characters in object names
SPOOL command
SQL*Plus, 10-4
SQL
aggregate functions, 6-14
arithmetic operators, 6-12
character functions, 6-11
character literals in statements, 6-3
column alias, 6-4
committing changes with COMMIT, 6-9
comparison operators, 6-4
creating a constraint, 6-16
creating a table, 6-15
Index-7
creating an index, 6-16

data definition language (DDL), 6-15
data manipulation language (DML), 6-7
date functions, 6-13
deleting rows in a table with DELETE, 6-8
displaying data from multiple tables, 6-6
dropping a sequence, 6-17
dropping a synonym, 6-18
dropping a table, 6-17
dynamic, 7-19
functions, 6-10
inserting rows in a table with INSERT, 6-7
joining tables in SELECT, 6-6
modifying a constraint, 6-16
modifying a table, 6-17
modifying an index, 6-16
numeric functions, 6-12
ORDER BY clause in SELECT, 6-5
overview of, 6-1
PL/SQL and, 7-1
pseudocolumns, 6-10
querying data, 6-2
retrieving data from tables, 6-2
SELECT statement, 6-2
sequences, 6-10, 6-11
statement types, 6-2
transaction control statements, 6-8
types of statements, 6-2
undoing changes with ROLLBACK, 6-9
updating data in a table with UPDATE, 6-8
using with Oracle Database, 6-1
WHERE clause in SELECT, 6-4
SQL functions
default values for NLS parameters, 11-22
NCHR, 11-21
NLS_INITCAP, 11-21
NLS_LOWER, 11-21
NLS_UPPER, 11-21
NLSSORT, 11-21
specifying NLS parameters, 11-22
TO_CHAR, 11-21
TO_DATE, 11-21
TO_NUMBER, 11-21
unacceptable NLS parameters, 11-24
UNISTR, 11-21
SQL scripts
running, 1-17
SQL statements
categories, 6-2
in trigger bodies, 9-3, 9-5
not allowed in triggers, 9-5
SQL Worksheet
using, 1-15
SQL*Plus
defining a variable, 10-5
DESCRIBE command, 10-3
displaying help, 10-2
entering commands and statements, 10-2
executing commands and statements, 10-2
Index-8
exiting, 10-2
HELP command, 10-2
location of executable, 3-24
overview, 10-1
prompting for a variable, 10-4
running SQL scripts, 10-3
SET command, 10-3
settings, 10-3
SPOOL command, 10-4
spooling output, 10-4
starting from the operating system command
prompt, 10-2
using, 1-18
using variables, 10-4
standalone subprograms, 8-2
execute, 8-3
managing, 8-3
statement triggers
conditional code for statements, 9-4
specifying SQL statement, 9-2
timing, 9-2
UPDATE statements and, 9-4
valid SQL statements, 9-5
statistics
computing table and column, 1-9
estimating table and column, 1-9
storage options, 3-12
STORAGE_ERROR exception, 7-22
stored subprograms, 8-2
in Oracle database, 8-2
storing, 5-2
string literals, 7-7
Unicode, 11-21
Structured Query Language (SQL), 6-1
subprograms
debugging, 3-22
declaring PL/SQL, 7-15
functions, 8-2
local, 8-2
managing, 8-3
overview, 8-1
packaged, 8-2
procedures, 8-2
running, 3-22
standalone, 8-2
stored, 8-2
SUBSCRIPT_BEYOND_COUNT exception, 7-22
SUBSCRIPT_OUTSIDE_LIMIT exception, 7-22
substitution variables, 1-18
synonyms
description, 4-11
managing, 4-11
SYS_INVALID_ROWID exception, 7-22
SYSDATE
pseudocolumn, 6-10
T
table-level constraints, 4-4
tables
aliases, 6-6
analyzing, 1-9
compacting, 1-9
computing statistics, 1-9
creating quickly, 3-7
decrypting column data, 1-10
encrypting column data, 1-9
entering and modifying data, 1-12
estimating statistics, 1-9
exporting data, 1-9, 3-20
locking, 1-9
managing, 4-2
moving to another tablespace, 1-9
primary key, 4-5
shrinking, 1-9
truncating, 1-9
territory definition, 11-6
territory support, 11-2
time and date data
storing, 5-5
time and date parameters, 11-7
time zone
parameters, 11-9, 11-10
TIMEOUT_ON_RESOURCE exception, 7-22
TIMESTAMP data type, 5-5
TIMESTAMP WITH LOCAL TIME ZONE data
type, 5-5
TIMESTAMP WITH TIME ZONE data type, 5-5
tnsnames.ora file, 1-11
TO_CHAR SQL function, 11-21
default date format, 11-8
group separator, 11-12
language for dates, 11-8
spelling of days and months, 11-9
TO_DATE function, 5-7
TO_DATE SQL function, 11-21
default date format, 11-8
language for dates, 11-8
spelling of days and months, 11-9
TO_NUMBER SQL function, 11-21
TOO_MANY_ROWS exception, 7-23
transactions
trigger
disabled
definition, 9-4
enabled
definition, 9-4
triggers
accessing column values, 9-3
AFTER, 9-2, 9-4
AFTER option, 9-2
as a stored PL/SQL subprogram, 9-1
BEFORE, 9-2, 9-4
BEFORE option, 9-2
body, 9-5
column list in UPDATE, 9-4
conditional predicates, 9-4
controlling when fired, 9-2
creating, 9-1, 9-5
designing, 9-5
detecting the operation that fired a trigger, 9-4
disabling, 9-4
enabling, 9-4
error conditions and exceptions, 9-4
errors, 9-4
events, 9-2
exceptions, 9-4
fired multiple times with BEFORE option, 9-3
FOR EACH ROW clause, 9-3
FOR EACH ROW option, 9-3
guidelines for design, 9-5
illegal SQL statements, 9-5
integrity constraints vs., 9-5
naming, 9-2
NEW column value, 9-3
OLD column value, 9-3
overview, 9-1
privileges, 9-6
privileges needed, 9-6
procedures and, 9-6
remote dependencies and, 9-6
restrictions, 9-3, 9-5
row, 9-3
triggering statement, 9-2
types, 9-2
WHEN clause, 9-3
when fired, 9-2
TRUE value, 7-7
truncating a table, 1-9
tutorial
creating objects for a small database, 2-1
TYPE attribute
declaring, 7-11
types
creating, 3-15
U
Unicode
PL/SQL and SQL, 11-19
programming, 11-2
programming with SQL and PL/SQL,
string literals, 11-21
unique constraints, 3-10
unique key
on a column, 4-5
UNIQUE key constraints
PRIMARY KEY constraint vs., 4-5
UNISTR SQL function, 11-21
unusable indexes, 1-6
UPDATE statement, 6-7, 6-8
11-18
Index-9
triggers and, 9-4

updates
checking for Raptor updates, 3-2
USER
pseudocolumn, 6-10
user interface (UI), 1-1
user-defined reports
explanation, 1-25
folders for, 1-25, 3-16
user-defined types
creating, 3-15
UTL_FILE package, 8-5
V
VALUE_ERROR exception, 7-23
VARCHAR2 data type, 5-1
variables
accessing in packages, 8-4
bind, 7-21
passing as IN OUT parameter, 7-15
using with SQL*Plus, 10-4
views
compiling, 1-10
description, 4-10
FROM clause, 3-18
GROUP BY clause, 3-19
HAVING clause, 3-19
managing, 4-10
ORDER BY clause, 3-19
recompiling, 1-10
SELECT clause, 3-18
WHERE clause, 3-19
visibility
of package contents, 8-3
W
WHEN clause, 9-3
cannot contain PL/SQL expressions,
WHERE clause, 3-19
WHILE-LOOP statement
overview, 7-13
Z
ZERO_DIVIDE exception, 7-23
Index-10
9-3

Online Help

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Online Help

Enviado por

Direitos autorais:

Formatos disponíveis

Oracle Raptor

Raptor Online Help, Release 1.0 Early Adopter

Copyright 2005, Oracle. All rights reserved.

Raptor Concepts and Usage

Raptor User Interface.................................................................................................................. 1-1

Tutorial: Creating Objects for a Small Database

Creating a Table (Books) ............................................................................................................ 2-1

Dialog Boxes for Creating/Editing Objects

Add Extension .............................................................................................................................

Create/Edit Trigger .................................................................................................................

Database Objects: Usage Information

Data Types: Usage Information

Overview of Data Types ............................................................................................................

SQL: Usage Information

Managing Views ...................................................................................................................... 4-10

Overview of SQL......................................................................................................................... 6-1

Using Arithmetic Operators............................................................................................

PL/SQL: Usage Information

Subprograms and Packages: Usage Information

Continuing After an Exception is Raised ...................................................................... 7-24

Overview of Packages and Subprograms ...............................................................................

Triggers: Usage Information

SQL*Plus: Usage Information

Working in a Global Environment

Overview of Globalization Support ...................................................................................... 11-1

1.1 Raptor User Interface

Raptor Concepts and Usage 1-1

Raptor User Interface

Icons under the menus perform the following actions:

Open opens a file (see Open File).

Save saves any changes to the currently selected object.

Save All saves any changes to all open objects.

1-2 Raptor Online Help

Raptor User Interface

Modify displays a dialog box for editing the object.

Raptor Concepts and Usage 1-3

Raptor User Interface

1.1.1 Menus for Raptor

1-4 Raptor Online Help

1.2 Database Objects

Raptor Concepts and Usage 1-5

1.2.1 Database Links

Test: Validates the database link.

Drop: Deletes the database link.

Drop: Deletes the function.

Compile: Performs a PL/SQL compilation of the function.

Compile Dependents: Performs a PL/SQL compilation of the function and any

Drop: Deletes the index.

1-6 Raptor Online Help

1.2.4 Materialized Views

1.2.5 Materialized View Logs

Raptor Concepts and Usage 1-7

Drop: Deletes the procedure.

Compile: Performs a PL/SQL compilation of the procedure.

Compile Dependents: Performs a PL/SQL compilation of the procedure and any

1.2.8 Recycle Bin

1.2.10 Synonyms (Public and Private)

1-8 Raptor Online Help

Rename: Renames the column.

1.2.14 Users (Other Users)

Edit: Displays the Create/Edit View dialog box.

Drop: Deletes the view.

1-10 Raptor Online Help

1.3 Database Connections