Oracle/SQL Tutorial

Oracle/SQL Tutorial1
Michael Gertz
Database and Information Systems Group
Department of Computer Science
University of California, Davis
gertz@cs.ucdavis.edu
http://www.db.cs.ucdavis.edu
This Oracle/SQL tutorial provides a detailed introduction to the SQL query language and the
Oracle Relational Database Management System. Further information about Oracle and SQL
can be found on the web site www.db.cs.ucdavis.edu/dbs.
Comments, corrections, or additions to these notes are welcome. Many thanks to Christina
Chung for comments on the previous version.
Recommended Literature
The complete Oracle Documentation is available online at technet.oracle.com. Free sub-
scription!
Oracle Press has several good books on various Oracle topics. See www.osborne.com/oracle/
O’Reilly has about 30 excellent Oracle books, including Steven Feuerstein’s Oracle PL/SQL
Programming (3rd edition). See oracle.oreilly.com.
Jim Melton and Alan R. Simon: SQL: 1999 - Understanding Relational Language Components
(1st Edition, May 2001), Morgan Kaufmann.
Jim Celko has a couple of very good books that cover advanced SQL queries and programming.
Check any of your favorite (online)bookstore.
If you want to know more about constraints and triggers, you might want to check the fol-
lowing article: Can T¨
urker and Michael Gertz: Semantic Integrity Support in SQL:1999 and
Commercial (Object-)Relational Database Management Systems. The VLDB Journal, Volume
10, Number 4, 241-269.
1revised Version 1.01, January 2000, Michael Gertz, Copyright 2000.

---

Contents
1. SQL – Structured Query Language
1.1. Tables
1
1.2. Queries (Part I)
3
1.3. Data Definition in SQL
6
1.4. Data Modifications in SQL
9
1.5. Queries (Part II)
11
1.6. Views
19
2. SQL*Plus (Minimal User Guide, Editor Commands, Help System)
20
3. Oracle Data Dictionary
23
4. Application Programming
4.1. PL/SQL
4.1.1 Introduction
26
4.1.2 Structure of PL/SQL Blocks
27
4.1.3 Declarations
27
4.1.4 Language Elements
28
4.1.5 Exception Handling
32
4.1.6 Procedures and Functions
34
4.1.7 Packages
36
4.1.8 Programming in PL/SQL
38
4.2. Embedded SQL and Pro*C
39
5. Integrity Constraints and Triggers
5.1. Integrity Constraints
5.1.1 Check Constraints
46
5.1.2 Foreign Key Constraints
47
5.1.3 More About Column- and Table Constraints
49
5.2. Triggers
5.2.1 Overview
50
5.2.2 Structure of Triggers
50
5.2.3 Example Triggers
53
5.2.4 Programming Triggers
55
6. System Architecture
6.1. Storage Management and Processes
58
6.2. Logical Database Structures
60
6.3. Physical Database Structures
61
6.4. Steps in Processing an SQL Statement
63
6.5. Creating Database Objects
63

---

1
SQL – Structured Query Language
1.1
Tables
In relational database systems (DBS) data are represented using tables (relations). A query
issued against the DBS also results in a table. A table has the following structure:
Column 1
Column 2
. . .
Column n
←− Tuple (or Record)
. . .
. . .
. . .
. . .
A table is uniquely identified by its name and consists of rows that contain the stored informa-
tion, each row containing exactly one tuple (or record ). A table can have one or more columns.
A column is made up of a column name and a data type, and it describes an attribute of the
tuples. The structure of a table, also called relation schema, thus is defined by its attributes.
The type of information to be stored in a table is defined by the data types of the attributes
at table creation time.
SQL uses the terms table, row, and column for relation, tuple, and attribute, respectively. In
this tutorial we will use the terms interchangeably.
A table can have up to 254 columns which may have different or same data types and sets of
values (domains), respectively. Possible domains are alphanumeric data (strings), numbers and
date formats. Oracle offers the following basic data types:
• char(n): Fixed-length character data (string), n characters long. The maximum size for
n is 255 bytes (2000 in Oracle8). Note that a string of type char is always padded on
right with blanks to full length of n. ( can be memory consuming).
Example: char(40)
• varchar2(n): Variable-length character string. The maximum size for n is 2000 (4000 in
Oracle8). Only the bytes used for a string require storage. Example: varchar2(80)
• number(o, d): Numeric data type for integers and reals. o = overall number of digits, d
= number of digits to the right of the decimal point.
Maximum values: o =38, d= −84 to +127. Examples: number(8), number(5,2)
Note that, e.g., number(5,2) cannot contain anything larger than 999.99 without result-
ing in an error. Data types derived from number are int[eger], dec[imal], smallint
and real.
• date: Date data type for storing date and time.
The default format for a date is: DD-MMM-YY. Examples: ’13-OCT-94’, ’07-JAN-98’
1

---

• long: Character data up to a length of 2GB. Only one long column is allowed per table.
Note: In Oracle-SQL there is no data type boolean. It can, however, be simulated by using
either char(1) or number(1).
As long as no constraint restricts the possible values of an attribute, it may have the special
value null (for unknown). This value is different from the number 0, and it is also different
from the empty string ’’.
Further properties of tables are:
• the order in which tuples appear in a table is not relevant (unless a query requires an
explicit sorting).
• a table has no duplicate tuples (depending on the query, however, duplicate tuples can
appear in the query result).
A database schema is a set of relation schemas. The extension of a database schema at database
run-time is called a database instance or database, for short.
1.1.1
Example Database
In the following discussions and examples we use an example database to manage information
about employees, departments and salary scales. The corresponding tables can be created
under the UNIX shell using the command demobld. The tables can be dropped by issuing
the command demodrop under the UNIX shell.
The table EMP is used to store information about employees:
EMPNO
ENAME
JOB
MGR
HIREDATE
SAL
DEPTNO
7369
SMITH
CLERK
7902
17-DEC-80
800
20
7499
ALLEN
SALESMAN
7698
20-FEB-81
1600
30
7521
WARD
SALESMAN
7698
22-FEB-81
1250
30
...........................................................
7698
BLAKE
MANAGER
01-MAY-81
3850
30
7902
FORD
ANALYST
7566
03-DEC-81
3000
10
For the attributes, the following data types are defined:
EMPNO:number(4), ENAME:varchar2(30), JOB:char(10), MGR:number(4),
HIREDATE:date, SAL:number(7,2), DEPTNO:number(2)
Each row (tuple) from the table is interpreted as follows: an employee has a number, a name,
a job title and a salary. Furthermore, for each employee the number of his/her manager, the
date he/she was hired, and the number of the department where he/she is working are stored.
2

---

The table DEPT stores information about departments (number, name, and location):
DEPTNO
DNAME
LOC
10
STORE
CHICAGO
20
RESEARCH
DALLAS
30
SALES
NEW YORK
40
MARKETING
BOSTON
Finally, the table SALGRADE contains all information about the salary scales, more precisely, the
maximum and minimum salary of each scale.
GRADE
LOSAL
HISAL
1
700
1200
2
1201
1400
3
1401
2000
4
2001
3000
5
3001
9999
1.2
Queries (Part I)
In order to retrieve the information stored in the database, the SQL query language is used. In
the following we restrict our attention to simple SQL queries and defer the discussion of more
complex queries to Section 1.5
In SQL a query has the following (simplified) form (components in brackets [ ] are optional):
select [distinct] <column(s)>
from <table>
[ where <condition> ]
[ order by <column(s) [asc|desc]> ]
1.2.1
Selecting Columns
The columns to be selected from a table are specified after the keyword select. This operation
is also called projection. For example, the query
select LOC, DEPTNO from DEPT;
lists only the number and the location for each tuple from the relation DEPT. If all columns
should be selected, the asterisk symbol “∗” can be used to denote all attributes. The query
select ∗ from EMP;
retrieves all tuples with all columns from the table EMP. Instead of an attribute name, the select
clause may also contain arithmetic expressions involving arithmetic operators etc.
select ENAME, DEPTNO, SAL ∗ 1.55 from EMP;
3

---

For the different data types supported in Oracle, several operators and functions are provided:
• for numbers: abs, cos, sin, exp, log, power, mod, sqrt, +, −, ∗, /, . . .
• for strings: chr, concat(string1, string2), lower, upper, replace(string, search string,
replacement string), translate, substr(string, m, n), length, to date, . . .
• for the date data type: add month, month between, next day, to char, . . .
The usage of these operations is described in detail in the SQL*Plus help system (see also
Section 2).
Consider the query
select DEPTNO from EMP;
which retrieves the department number for each tuple. Typically, some numbers will appear
more than only once in the query result, that is, duplicate result tuples are not automatically
eliminated.
Inserting the keyword distinct after the keyword select, however, forces the
elimination of duplicates from the query result.
It is also possible to specify a sorting order in which the result tuples of a query are displayed.
For this the order by clause is used and which has one or more attributes listed in the select
clause as parameter. desc specifies a descending order and asc specifies an ascending order
(this is also the default order). For example, the query
select ENAME, DEPTNO, HIREDATE from EMP;
from EMP
order by DEPTNO [asc], HIREDATE desc;
displays the result in an ascending order by the attribute DEPTNO. If two tuples have the same
attribute value for DEPTNO, the sorting criteria is a descending order by the attribute values of
HIREDATE. For the above query, we would get the following output:
ENAME
DEPTNO
HIREDATE
FORD
10
03-DEC-81
SMITH
20
17-DEC-80
BLAKE
30
01-MAY-81
WARD
30
22-FEB-81
ALLEN
30
20-FEB-81
...........................
1.2.2
Selection of Tuples
Up to now we have only focused on selecting (some) attributes of all tuples from a table. If one is
interested in tuples that satisfy certain conditions, the where clause is used. In a where clause
simple conditions based on comparison operators can be combined using the logical connectives
and, or, and not to form complex conditions. Conditions may also include pattern matching
operations and even subqueries (Section 1.5).
4

---

Example:
List the job title and the salary of those employees whose manager has the
number 7698 or 7566 and who earn more than 1500:
select JOB, SAL
from EMP
where (MGR = 7698 or MGR = 7566) and SAL > 1500;
For all data types, the comparison operators =, != or <>, <, >, <=, => are allowed in the
conditions of a where clause.
Further comparison operators are:
• Set Conditions: <column> [not] in (<list of values>)
Example: select ∗ from DEPT where DEPTNO in (20,30);
• Null value: <column> is [not] null,
i.e., for a tuple to be selected there must (not) exist a defined value for this column.
Example: select ∗ from EMP where MGR is not null;
Note: the operations = null and ! = null are not defined!
• Domain conditions: <column> [not] between <lower bound> and <upper bound>
Example: • select EMPNO, ENAME, SAL from EMP
where SAL between 1500 and 2500;
• select ENAME from EMP
where HIREDATE between ’02-APR-81’ and ’08-SEP-81’;
1.2.3
String Operations
In order to compare an attribute with a string, it is required to surround the string by apos-
trophes, e.g., where LOCATION = ’DALLAS’. A powerful operator for pattern matching is the
like operator. Together with this operator, two special characters are used: the percent sign
% (also called wild card), and the underline
, also called position marker. For example, if
one is interested in all tuples of the table DEPT that contain two C in the name of the depart-
ment, the condition would be where DNAME like ’%C%C%’. The percent sign means that any
(sub)string is allowed there, even the empty string. In contrast, the underline stands for exactly
one character. Thus the condition where DNAME like ’%C C%’ would require that exactly one
character appears between the two Cs. To test for inequality, the not clause is used.
Further string operations are:
• upper(<string>) takes a string and converts any letters in it to uppercase, e.g., DNAME
= upper(DNAME) (The name of a department must consist only of upper case letters.)
• lower(<string>) converts any letter to lowercase,
• initcap(<string>) converts the initial letter of every word in <string> to uppercase.
• length(<string>) returns the length of the string.
• substr(<string>, n [, m]) clips out a m character piece of <string>, starting at position
n. If m is not specified, the end of the string is assumed.
substr(’DATABASE SYSTEMS’, 10, 7) returns the string ’SYSTEMS’.
5

---

1.2.4
Aggregate Functions
Aggregate functions are statistical functions such as count, min, max etc. They are used to
compute a single value from a set of attribute values of a column:
count
Counting Rows
Example: How many tuples are stored in the relation EMP?
select count(∗) from EMP;
Example: How many different job titles are stored in the relation EMP?
select count(distinct JOB) from EMP;
max
Maximum value for a column
min
Minimum value for a column
Example: List the minimum and maximum salary.
select min(SAL), max(SAL) from EMP;
Example: Compute the difference between the minimum and maximum salary.
select max(SAL) - min(SAL) from EMP;
sum
Computes the sum of values (only applicable to the data type number)
Example: Sum of all salaries of employees working in the department 30.
select sum(SAL) from EMP
where DEPTNO = 30;
avg
Computes average value for a column (only applicable to the data type number)
Note:
avg, min and max ignore tuples that have a null value for the specified
attribute, but count considers null values.
1.3
Data Definition in SQL
1.3.1
Creating Tables
The SQL command for creating an empty table has the following form:
create table <table> (
<column 1> <data type> [not null] [unique] [<column constraint>],
. . . . . . . . .
<column n> <data type> [not null] [unique] [<column constraint>],
[<table constraint(s)>]
);
For each column, a name and a data type must be specified and the column name must be
unique within the table definition. Column definitions are separated by comma. There is no
difference between names in lower case letters and names in upper case letters. In fact, the
only place where upper and lower case letters matter are strings comparisons. A not null
6

---

constraint is directly specified after the data type of the column and the constraint requires
defined attribute values for that column, different from null.
The keyword unique specifies that no two tuples can have the same attribute value for this
column. Unless the condition not null is also specified for this column, the attribute value
null is allowed and two tuples having the attribute value null for this column do not violate
the constraint.
Example: The create table statement for our EMP table has the form
create table EMP (
EMPNO
number(4) not null,
ENAME
varchar2(30) not null,
JOB
varchar2(10),
MGR
number(4),
HIREDATE
date,
SAL
number(7,2),
DEPTNO
number(2)
);
Remark: Except for the columns EMPNO and ENAME null values are allowed.
1.3.2
Constraints
The definition of a table may include the specification of integrity constraints. Basically two
types of constraints are provided: column constraints are associated with a single column
whereas table constraints are typically associated with more than one column. However, any
column constraint can also be formulated as a table constraint. In this section we consider only
very simple constraints. More complex constraints will be discussed in Section 5.1.
The specification of a (simple) constraint has the following form:
[constraint <name>]
primary key | unique | not null
A constraint can be named. It is advisable to name a constraint in order to get more meaningful
information when this constraint is violated due to, e.g., an insertion of a tuple that violates
the constraint. If no name is specified for the constraint, Oracle automatically generates a
name of the pattern SYS C<number>.
The two most simple types of constraints have already been discussed: not null and unique.
Probably the most important type of integrity constraints in a database are primary key con-
straints. A primary key constraint enables a unique identification of each tuple in a table.
Based on a primary key, the database system ensures that no duplicates appear in a table. For
example, for our EMP table, the specification
create table EMP (
EMPNO
number(4) constraint pk emp primary key,
. . . );
7

---

defines the attribute EMPNO as the primary key for the table. Each value for the attribute EMPNO
thus must appear only once in the table EMP. A table, of course, may only have one primary
key. Note that in contrast to a unique constraint, null values are not allowed.
Example:
We want to create a table called PROJECT to store information about projects. For each
project, we want to store the number and the name of the project, the employee number of
the project’s manager, the budget and the number of persons working on the project, and
the start date and end date of the project. Furthermore, we have the following conditions:
- a project is identified by its project number,
- the name of a project must be unique,
- the manager and the budget must be defined.
Table definition:
create table PROJECT (
PNO
number(3) constraint prj pk primary key,
PNAME
varchar2(60) unique,
PMGR
number(4) not null,
PERSONS
number(5),
BUDGET
number(8,2) not null,
PSTART
date,
PEND
date);
A unique constraint can include more than one attribute. In this case the pattern unique(<column
i>, . . . , <column j>) is used. If it is required, for example, that no two projects have the same
start and end date, we have to add the table constraint
constraint no same dates unique(PEND, PSTART)
This constraint has to be defined in the create table command after both columns PEND and
PSTART have been defined. A primary key constraint that includes more than only one column
can be specified in an analogous way.
Instead of a not null constraint it is sometimes useful to specify a default value for an attribute
if no value is given, e.g., when a tuple is inserted. For this, we use the default clause.
Example:
If no start date is given when inserting a tuple into the table PROJECT, the project start
date should be set to January 1st, 1995:
PSTART date default(’01-JAN-95’)
Note: Unlike integrity constraints, it is not possible to specify a name for a default.
8

---