



What is SQL*Plus?
Command Line Editor
Useful SQL*Plus Commands
Useful System Tables


What is PL/SQL?
PL/SQL Constructs
2


Oracle’s development environment

Used to write, test and debug SQL and
PL/SQL code

Hasn’t changed much in 20 years
3

Command Line Editor



 list or list # change

Example: /Featuer/Feature (can use any delimiter) del


 del (current line only) del 3 7 (range of lines) del 2 LAST (deletes from line 2 to the end of the buffer)

Do NOT use the word “delete” clear buffer: clears out the SQL statement
4

Command Line Editor

 append

Places text at the end of the current line without any spaces between the existing text & the appended text input
5

Useful SQL*Plus Commands


 set headsep: identifies the character that tells SQL*Plus when to split a title or column onto 2 or more lines


Default character: |






SQL> SELECT LNAME "Last_Name|Of|Employee" will display
Last_Name
Of
Employee
---------------
Set headsep !
ttitle: sets the title at the top of each page

 ttitle ‘Sales by Product During 1901!Second Six Months’
If title should display an apostrophe, then use two single quotes btitle: sets the title at the bottom of each page
6

Useful SQL*Plus Commands
 column: tells SQL*Plus how to handle columns




Can be used to re-label column headings
 column Item heading ‘What Was!Sold’
Can be used to specify column format

 column Item format a18 column Rate format 90.99

 zero tells SQL*Plus to pad the number with a zero (if necessary)
999,999,999 99.90
Can be used to truncate data in column
 column Item truncated (OR column Item trunc)
Can be used to wrap info column Item word_wrapped
7

Useful SQL*Plus Commands
 column: tells SQL*Plus how to handle columns

Can be used to specify column format

Alphanumeric: column Item format a18

Numeric: column Rate format 90.99


Use nines and zeros to specify the numeric pattern
Examples: (a) 999,999,999 (b) 99.90


COLUMN Salary FORMAT $999,999.99
See “numeric formatting” in Oracle Complete Reference
8

Useful SQL*Plus Commands

 break on: tells SQL*Plus where to break for subtotals and totals



 break on Item skip 2

 will not repeat the value in the Item column
Create one line for each unique Item value and skip 2 lines break on Item duplicate skip 2
 will repeat the value in the Item column must be coordinated with the order by clause break on report
 tells SQL*Plus to provide a grand total for the report

Example: break on Item skip 2 on report
 break on report on Item skip 2 compute sum: tells SQL*Plus to calculate subtotals
 works in conjunction with the break on command
9

Useful SQL*Plus Commands

Basic rules for computing subtotals & totals:

Every break on must have a related order by




Consecutive break on commands will override the previous break on command
To create both subtotals & totals, combine the break on instructions as follows


 break on X skip # on report OR break on report on X skip # where X = column name & # = lines to skip between sections
Every compute sum must have a related break on
Clear breaks and computes before setting up new ones
10

Useful SQL*Plus Commands


 set linesize
 sets the maximum number of characters allowed on any line; usually 70 or 80 set pagesize
 sets the maximum number of lines per page; usually 66 lines set newpage
 sets the number of blank lines between pages
11

Useful SQL*Plus Commands




 spool & spool off

Example: spool test.sql
run (/) start (@) save

 saves the SQL statements, but not the SQL*Plus commands
Example: save example.sql

(or save example.sql replace) store

 saves the current SQL*Plus environment
Example: store set my_settings.sql create

(or …replace or …append)
12

Useful SQL*Plus Commands

To check the current settings
 column (or column column_name)

 ttitle btitle





 break compute show headsep show linesize show pagesize show newpage
13

Useful SQL*Plus Commands

To clear the current settings

 ttitle off btitle off


 clear columns clear breaks clear computes
14

Useful System Tables




User_Constraints


Useful fields: constraint_name, table_name, constraint_type constraint_type: C, P, R & U
User_Cons_Columns

Useful fields: constraint_name, column_name, position
SELECT column_name
FROM user_cons_columns
WHERE constraint_name=‘SYS_C0008791’;
Retrieving constraints defined by the user
WHERE CONSTRAINT_NAME NOT LIKE '%SYS%';
15

Useful System Tables

 user_sequences

Contains sequences owned by the current user user_errors


Contains compilation errors for the current user
Use the ‘show errors’ SQL*Plus command to view the errors in the user_errors table
16




PL/SQL stands for Procedural Language operating on or using SQL
Combines the flexibility of SQL (4GL) with the power and configurability of the procedural constructs of a
3GL
Extends SQL by adding 3GL constructs such as:




Variables and types (predefined and user defined)
Control Structures (IF-THEN-ELSE, Loops)
Procedures and functions
Object types and methods
17


PL/SQL based on Ada language constructs

Block Structure





Error Handling
Variables and Types
Conditionals
Looping Constructs
Cursors
18




PL/SQL stands for Procedural Language operating on or using SQL
Combines power and flexibility of SQL (4GL) with procedural constructs of a 3GL
Extends SQL by adding


Variables and types
Control Structures


Procedures and functions
Object types and methods
20

Demonstrates both SQL and PL/SQL commands
DECLARE v_NewMajor VARCHAR2(10) := 'History'; v_FirstName VARCHAR2(10) := 'Scott'; v_LastName VARCHAR2(10) := 'Urman';
BEGIN
UPDATE students
SET major = v_NewMajor
WHERE first_name = v_FirstName
AND last_name = v_LastName;
IF SQL%NOTFOUND THEN
INSERT INTO students (ID, first_name, last_name, major)
VALUES (student_sequence.NEXTVAL, v_FirstName, v_LastName, v_NewMajor);
END IF;
END;
/
21




SQL results in many network trips, one for each SQL statement
PL/SQL permits several SQL statements to be bundled into a single block
Results in fewer calls to database


Less network traffic faster response time
22






Block Structure
Error Handling
Variables and Types
Looping Constructs
Cursors
23




Basic unit of PL/SQL is a block

Three possible sections of a block

Declarative section


Executable section
Exception handling
A block performs a logical unit of work in the program
Blocks can be nested
24



Exception handling section permits the user to trap and respond to run-time errors
Exceptions can be associated with


Predefined Oracle errors
User-defined errors
25

Illustrates an exception handler
DECLARE v_ErrorCode NUMBER; v_ErrorMsg VARCHAR2(200); v_CurrentUser VARCHAR2(8); v_Information VARCHAR2(100);
BEGIN
/* Code which processes some data here */
NULL;
-- (continued)
-- Code for the error
-- Message text for the error
-- Current database user
-- Information about the error
26

Illustrates an exception handler
EXCEPTION
WHEN OTHERS THEN v_ErrorCode := SQLCODE; v_ErrorMsg := SQLERRM; v_CurrentUser := USER; v_Information := 'Error encountered on ' ||
TO_CHAR(SYSDATE) || ' by database user ' || v_CurrentUser;
INSERT INTO log_table (code, message, info)
VALUES (v_ErrorCode, v_ErrorMsg, v_Information);
END;
/
27





A variable is a named location in memory that:
 can be read from
 assigned a value
Declared in the declaration section
Variables have a specific type associated with them
Can be same type as database columns
28



A loop allows execution of a set of statements repeatedly
Types of loops



Simple loop
Numeric For loop
While loop
29

Demonstrates a simple loop
DECLARE v_LoopCounter BINARY_INTEGER := 1;
BEGIN
LOOP
INSERT INTO temp_table (num_col)
VALUES (v_LoopCounter); v_LoopCounter := v_LoopCounter + 1;
EXIT WHEN v_LoopCounter > 50;
END LOOP;
END;
/
30

Demonstrates a numeric FOR loop
BEGIN
FOR v_LoopCounter IN 1..50 LOOP
INSERT INTO temp_table (num_col)
VALUES (v_LoopCounter);
END LOOP;
END;
/
31



A cursor creates a named context area as a result of executing an associated
SQL statement
Permits the program to step through the multiple rows displayed by an SQL statement
32

Demonstrates a cursor fetch loop
DECLARE v_FirstName VARCHAR2(20); v_LastName VARCHAR2(20);
CURSOR c_Students IS
SELECT first_name, last_name
FROM students;
BEGIN
OPEN c_Students;
LOOP
FETCH c_Students INTO v_FirstName, v_LastName;
EXIT WHEN c_Students%NOTFOUND;
/* Process data here */
END LOOP;
CLOSE c_Students;
END; 33

Illustrates a conditional statement
DECLARE v_TotalStudents NUMBER;
BEGIN
SELECT COUNT(*)
INTO v_TotalStudents
FROM students;
-- (continued)
34

Illustrates a conditional statement
IF v_TotalStudents = 0 THEN
INSERT INTO temp_table (char_col)
VALUES ('There are no students registered');
ELSIF v_TotalStudents < 5 THEN
INSERT INTO temp_table (char_col)
VALUES ('There are only a few students registered');
ELSIF v_TotalStudents < 10 THEN
INSERT INTO temp_table (char_col)
VALUES ('There are a little more students registered');
ELSE
INSERT INTO temp_table (char_col)
VALUES ('There are many students registered');
END IF;
END;
/ 35

Illustrates a stored procedure
CREATE OR REPLACE PROCEDURE PrintStudents( p_Major IN students.major%TYPE) AS
CURSOR c_Students IS
SELECT first_name, last_name
FROM students
WHERE major = p_Major;
BEGIN
FOR v_StudentRec IN c_Students LOOP
DBMS_OUTPUT.PUT_LINE(v_StudentRec.first_name || ' ' || v_StudentRec.last_name);
END LOOP;
END;
/
36

Illustrates a stored procedure
BEGIN
PrintStudents ('Computer Science');
END;
/
37


All of the named examples used in the book are on the accompanying CD
38


Tables used throughout text
 classes – describes the classes available for the students to take



 debug_table – used during debugging sessions log_table – records Oracle errors major_stats – holds statistics generated about different majors registered_students – contains information about the classes students are currently taking
39


Tables used throughout text
 rooms – holds information about the classrooms available




RS_audit – used to record changes made to registered students student_sequence – generates unique values for the primary key of the students students – contains information about students attending the school temp_table – stores temporary data
40

PROMPT student_sequence...
DROP SEQUENCE student_sequence;
CREATE SEQUENCE student_sequence
START WITH 10000
INCREMENT BY 1;
PROMPT students table...
DROP TABLE students CASCADE CONSTRAINTS;
CREATE TABLE students ( id NUMBER(5) PRIMARY KEY, first_name VARCHAR2(20), last_name VARCHAR2(20),
…
); major VARCHAR2(30), current_credits NUMBER(3)
41

(
CREATE TABLE classes department course description max_students current_students num_credits
CHAR (3),
NUMBER (3),
VARCHAR2 (2000),
NUMBER (3),
NUMBER (3),
NUMBER (1), room_id NUMBER (5),
CONSTRAINT classes_department_course
PRIMARY KEY (department, course),
CONSTRAINT classes_room_id
FOREIGN KEY (room_id) REFERENCES rooms (room_id)
);
42

(
CREATE TABLE debug_table linecount debug_str
NUMBER,
VARCHAR2 (100)
);
43

CREATE VIEW exception_view AS
SELECT exception exception_description, date_occurred
FROM exception_table;
44

(
CREATE TABLE log_table code message
NUMBER,
VARCHAR2 (200),
); info VARCHAR2 (100)
45

(
CREATE TABLE major_stats major VARCHAR2 (30), total_credits NUMBER,
); total_students NUMBER
46

(
CREATE TABLE registered_students student_id department course grade
NUMBER (5)
CHAR (3)
NUMBER (3)
CHAR (1),
NOT NULL,
NOT NULL,
NOT NULL,
CONSTRAINT rs_grade
CHECK (grade IN ('A', 'B', 'C', 'D', 'E')),
);
CONSTRAINT rs_student_id
FOREIGN KEY (student_id) REFERENCES students (id),
CONSTRAINT rs_department_course
FOREIGN KEY (department, course)
REFERENCES classes (department, course)
47

(
CREATE TABLE rooms room_id building
NUMBER (5)
VARCHAR2 (15),
); room_number NUMBER (4), number_seats NUMBER (4), description VARCHAR2 (50)
PRIMARY KEY,
48

(
CREATE TABLE RS_audit change_type changed_by timestamp old_student_id old_department old_course old_grade new_student_id new_department new_course
); new_grade
CHAR (1) NOT NULL,
VARCHAR2 (8) NOT NULL,
DATE
NUMBER (5),
CHAR (3),
NUMBER (3),
NOT NULL,
CHAR (1),
NUMBER (5),
CHAR (3),
NUMBER (3),
CHAR (1)
49

CREATE SEQUENCE student_sequence
START WITH 10000
INCREMENT BY 1;
50

(
CREATE TABLE students id NUMBER(5) PRIMARY KEY, first_name VARCHAR2 (20), last_name VARCHAR2 (20), major VARCHAR2 (30),
); current_credits NUMBER(3)
51

(
CREATE TABLE temp_table num_col char_col
NUMBER,
VARCHAR2 (60)
);
52




PL/SQL is a sophisticated programming language used to access an Oracle database
Procedural constructs are integrated seamlessly with SQL, resulting in a structured, powerful language
Combines flexibility of SQL with the configure ability of a 3GL
53