Oracle Database 9i Program With PLSQL (한글판) 볼륨 I - 학생용

Oracle9i: Program with PL/SQL
(한글판)
볼륨 1 • 학생용
n l y
e O
U s
A I
O
l &
na
te r
I n
c l e
40054KR11
ra
제품 1.1
2002년 2월
OD34371
만든이 Copyright © Oracle Corporation, 2000, 2001. All rights reserved.
Nagavalli Pataballa 이 문서는 Oracle Corp.의 독점적 정보를 포함하고 있습니다. 이 정보는 사용 제한 및
기밀 유지 규정을 포함하는 사용권 계약에 따라 제공되며 저작권법에 의해 보호됩니다.
Priya Nathan
이 소프트웨어를 리버스 엔지니어링 하는 것은 금지되어 있습니다. 이 문서를 미국
국방성 내의 정부 기관에 제공할 때는 제한된 권리 규정이 적용되며 다음 범례를 적용
할 수 있습니다.
기술 제공자 및 Restricted Rights Legend
검토자 Use, duplication or disclosure by the Government is subject to restrictions for

commercial computer software and shall be deemed to be Restricted Rights software
Anna Atkinson under Federal law, as set forth in subparagraph (c)(1)(ii) of DFARS 252.227-7013,
Bryan Roberts Rights in Technical Data and Computer Software (October 1988).
Caroline Pereda
This material or any portion of it may not be copied in any form or by any means
Cesljas Zarco
without the express prior written permission of Oracle Corporation. Any other copying
Coley William is a violation of copyright law and may result in civil and/or criminal penalties.
Daniel Gabel
Dr. Christoph Burandt If this documentation is delivered to a U.S. Government Agency not within the
Department of Defense, then it is delivered with “Restricted Rights,” as defined in
Hakan Lindfors FAR 52.227-14, Rights in Data-General, including Alternate III (June 1987).
Helen Robertson
John Hoff The information in this document is subject to change without notice. If you find any
Lachlan Williams problems in the documentation, please report them in writing to Education Products,
Oracle Corporation, 500 Oracle Parkway, Box SB-6, Redwood Shores, CA 94065.
Laszlo Czinkoczki Oracle Corporation does not warrant that this document is error-free.
Laura Pezzini
Linda Boldt Oracle and all references to Oracle products are trademarks or registered trademarks
Marco Verbeek of Oracle Corporation.
Natarajan Senthil
y
인용된 모든 다른 회사명 또는 제품명은 명시의 목적으로만 사용되었고 각 소유 회사들
Priya Vennapusa
Roger Abuzalaf
Ruediger Steffan
의 상표일 수 있습니다.
n l
Sarah Jones
Stefan Lindblad
e O
Susan Dee
U s
발행인
Sheryl Domingue
A I
O
l &
n a
te r
I n
c l e
r a
O
목차
교과 과정표
I 입문
과정 목표 I-2
PL/SQL I-3
PL/SQL 환경 I-4
PL/SQL의 장점 I-5
서브 프로그램의 장점 I-10
내장 프로시저 및 함수 호출 I-11
요약 I-12
1 변수 선언
목표 1-2
PL/SQL 블록 구조 1-3
명령문 및 PL/SQL 블록 실행 1-4
블록 유형 1-5
프로그램 생성자 1-6
변수 사용 1-7
PL/SQL에서 변수 처리 1-8
변수 유형 1-9
PL/SQL 블록 내에 iSQL*Plus 변수 사용 1-10 n l y
변수 유형 1-11
PL/SQL 변수 선언 1-12
e O
PL/SQL 변수 선언 지침 1-13
이름 지정 규칙 1-14
U s
변수 초기화 및 키워드 1-15
스칼라 데이터 유형 1-17 A I
기본 스칼라 데이터 유형 1-18
O
스칼라 변수 선언 1-22
%TYPE 속성 1-23
l &
%TYPE 속성을 사용하여 변수 선언 1-24
n a
부울 변수 선언 1-25
조합 데이터 유형 1-26
te r
바인드 변수 1-28I n
LOB 데이터 유형 변수 1-27
l e
바인드 변수 사용 1-30
c
비 PL/SQL 변수 참조 1-31
ra
DBMS_OUTPUT.PUT_LINE 1-32
O
요약 1-33
연습 1 개요 1-35
iii
2 샐행문 작성
목표 2-2
PL/SQL 블록 구문 및 지침 2-3
식별자 2-5
PL/SQL 블록 구문 및 지침 2-6
코드에 주석 달기 2-7
PL/SQL의 SQL 함수 2-8
PL/SQL의 SQL 함수: 예제 2-9
데이터 유형 변환 2-10
중첩 블록 및 변수 범위 2-13
식별자 범위 2-15
식별자의 명확한 지정 2-16
변수 범위의 확인 2-17
PL/SQL의 연산자 2-18
프로그래밍 지침 2-20
코드 들여쓰기 2-21
요약 2-22
연습 2 개요 2-23
3 Oracle Server와의 상호 작용
목표 3-2 n l y
PL/SQL의 SQL 문 3-3
PL/SQL의 SELECT 문 3-4
e O
PL/SQL에서 데이터 검색 3-7
U s
PL/SQL을 사용하여 데이터 조작 3-10
데이터 삽입 3-11 A I
데이터 갱신 3-12
O
데이터 삭제 3-13
행 병합 3-14
l &
n a
SQL 커서 3-18
SQL 커서 속성 3-19
te r
트랜잭션 제어문 3-21
요약 3-22 I n
l e
연습 3 개요 3-24
c
ra
O
iv
4 제어 구조 작성
목표 4-2
PL/SQL 실행 순서 제어 4-3
IF 문 4-4
단순 IF 문 4-5
혼합 IF 문 4-6
IF-THEN-ELSE 문 실행 흐름 4-7
IF-THEN-ELSE 문 4-8
IF-THEN-ELSE 문 실행 흐름 4-9
IF-THEN-ELSE 문 4-11
CASE 표현식 4-12
CASE 표현식: 예제 4-13
NULL 처리 4-15
논리 테이블 4-16
부울 조건 4-17
반복 제어: LOOP 문 4-18
기본 루프 4-19
WHILE 루프 4-21
FOR 루프 4-23
루프 사용 지침 4-26
중첩 루프와 레이블 4-27
n l y
요약 4-29
연습 4 개요 4-30
e O
5 조합 데이터 유형 사용
U s
목표 5-2
조합 데이터 유형 5-3 A I
PL/SQL 레코드 5-4
O
PL/SQL 레코드 생성 5-5
PL/SQL 레코드 구조 5-7
l &
%ROWTYPE 속성 5-8
n a
%ROWTYPE 속성 5-11
te r
%ROWTYPE 사용의 장점 5-10
I n
INDEX BY 테이블 5-13
INDEX BY 테이블 생성 5-14
l e
INDEX BY 테이블 구조 5-15
c
INDEX BY 테이블 생성 5-16
ra
INDEX BY 테이블 메소드 사용 5-17
O
레코드의 INDEX BY 테이블 5-18
레코드의 INDEX BY 테이블 예제 5-19
요약 5-20
연습 5 개요 5-21
v
6 명시적 커서 작성
목표 6-2
커서 6-3
명시적 커서(explicit cursor) 기능 6-4
명시적 커서(explicit cursor) 제어 6-5
커서 선언 6-9
커서 열기 6-11
커서에서 데이터 인출(fetch) 6-12
커서 닫기 6-14
명시적 커서(explicit cursor) 속성 6-15
%ISOPEN 속성 6-16
복수 인출(fetch) 제어 6-17
%NOTFOUND 및 %ROWCOUNT 속성 6-18
예제 6-20
커서 및 레코드 6-21
커서 FOR 루프 6-22
서브 쿼리를 사용하는 커서 FOR 루프 6-24
요약 6-26
연습 6 개요 6-27
7 고급 명시적 커서 개념
n l y
목표 7-2
파라미터 사용 커서 7-3
e O
FOR UPDATE 절 7-5
WHERE CURRENT OF 절 7-7
U s
서브 쿼리 포함 커서 7-9
요약 7-10
A I
연습 7 개요 7-11
O
8 예외 처리
l &
목표 8-2
n a
PL/SQL로 예외 처리 8-3
예외 처리 8-4
te r
예외 유형 8-5
예외 트랩 8-6 I n
l e
예외 트랩 지침 8-7
c
미리 정의된 Oracle Server 오류 트랩 8-8
ra
미리 정의된 예외 8-11
O
미리 정의되지 않은 Oracle Server 오류 트랩 8-12
미리 정의되지 않은 오류 8-13
예외 트랩 함수 8-14
사용자가 정의한 예외 트랩 8-16
사용자가 정의한 예외 8-17
vi
호출 환경 8-18
예외 전달 8-19
RAISE_APPLICATION_ERROR 프로시저 8-20
RAISE_APPLICATION_ERROR 8-22
요약 8-23
연습 8 개요 8-24
9 프로시저 작성
목표 9-2
PL/SQL 프로그램 생성자 9-4
서브 프로그램 개요 9-5
익명 PL/SQL 블록의 블록 구조 9-6
PL/SQL 서브 프로그램의 블록 구조 9-7
PL/SQL 서브 프로그램 9-8
서브 프로그램의 장점 9-9
iSQL*Plus를 사용하여 서브 프로그램 개발 9-10
내장 프로시저 및 함수 호출 9-11
프로시저란? 9-12
프로시저 작성 구문 9-13
프로시저 개발 9-14
형식 매개변수와 실제 매개변수 9-15 n l y
프로시저 파라미터 모드 9-16
파라미터를 사용하여 프로시저 작성 9-17
e O
IN 파라미터: 예제 9-18
OUT 파라미터: 예제 9-19
U s
OUT 파라미터 보기 9-21
IN OUT 파라미터 9-22
A I
IN OUT 파라미터 보기 9-23
O
파라미터 전달 방식 9-24
파라미터의 DEFAULT 옵션 9-25
l &
파라미터 전달 예제 9-26
n a
서브 프로그램 선언 9-27
te r
익명 PL/SQL 블록에서 프로시저 호출 9-28
I
처리된 예외 9-30n
다른 프로시저에서 프로시저 호출 9-29
l e
처리되지 않은 예외 9-32
c
프로시저 제거 9-34
r a
요약 9-35
O 연습 9 개요 9-37
10 함수 작성
목표 10-2
내장 함수 개요 10-3
vii
함수 작성 구문 10-4
함수 작성 10-5
iSQL*Plus를 사용하여 내장 함수 작성 10-6
iSQL*Plus를 사용하여 내장 함수 작성: 예제 10-7
함수 실행 10-8
함수 실행: 예제 10-9
SQL 표현식에서 사용자가 정의한 함수 사용 시 장점 10-10
SQL 표현식에서 함수 호출: 예제 10-11
사용자가 정의한 함수의 호출 위치 10-12
SQL 표현식에서 함수 호출 시 제한 사항 10-13
SQL에서 호출 시 제한 사항 10-15
함수 제거 10-16
프로시저와 함수 비교 10-17
프로시저와 함수 비교 10-18
내장 프로시저 및 함수의 장점 10-19
요약 10-20
연습 10 개요 10-21
11 서브 프로그램 관리
목표 11-2
필수 권한 11-3 n l y
데이터에 대한 액세스 권한 부여 11-4
호출자 권한 사용 11-5
e O
내장 PL/SQL 객체 관리 11-6
USER_OBJECTS 11-7
U s
모든 프로시저 및 함수 나열 11-8
USER_SOURCE 데이터 딕셔너리 뷰 11-9
A I
프로시저 및 함수 코드 표시 11-10
O
USER_ERRORS 11-11
컴파일 오류 감지: 예제 11-12
l &
a
USER_ERRORS를 사용하여 컴파일 오류 표시 11-13
n
te r
SHOW ERRORS를 사용하여 컴파일 오류 표시 11-14
iSQL*Plus의 DESCRIBE 11-15
요약 11-17 I n
PL/SQL 프로그램 단위 디버깅 11-16
le
연습 11 개요 11-19
c
r a
12 패키지 작성
O 목표 12-2
패키지 개요 12-3
패키지 구성 요소 12-4
패키지 객체 참조 12-5
패키지 개발 12-6
viii
패키지 명세(specification) 작성 12-8
공용(public) 생성자 선언 12-9
패키지 명세(specification) 작성: 예제 12-10
패키지 몸체(body) 작성 12-11
공용(public) 및 전용(private) 생성자 12-12
패키지 몸체(body) 작성: 예제 12-13
패키지 생성자 호출 12-15
몸체(body) 없는 패키지 선언 12-17
독립형 프로시저에서 공용(public) 변수 참조 12-18
패키지 제거 12-19
패키지 개발 지침 12-20
패키지의 장점 12-21
요약 12-23
연습 12 개요 12-26
13 패키지 개념 추가 정보
목표 13-2
오버로드 13-3
오버로드: 예제 13-5
사전 선언 사용 13-8
1회 실행 프로시저 작성 13-10 n l y
SQL에 사용되는 패키지 함수 제한 사항 13-11
사용자가 정의한 패키지: taxes_pack 13-12
e O
SQL 문에서 사용자가 정의한 패키지 함수 호출 13-13
패키지 변수의 지속 상태: 예제 13-14
U s
패키지 변수의 지속 상태 13-15
패키지 커서의 지속 상태 제어 13-18 A I
PACK_CUR 실행 13-20
O
요약 13-22
l &
패키지 내의 PL/SQL 테이블 및 레코드 13-21
연습 13 개요 13-23
n a
14 오라클 지원 패키지
te r
목표 14-2
I n
c le
지원 패키지 사용 14-3
고유 동적 SQL 사용 14-4
r a
실행 순서 14-5
DBMS_SQL 패키지 사용 14-6
O DBMS_SQL 사용 14-8
EXECUTE IMMEDIATE 문 사용 14-9
EXECUTE IMMEDIATE를 사용하는 동적 SQL 14-11
DBMS_DDL 패키지 사용 14-12
일정 계획에 DBMS_JOB 사용 14-13
ix
DBMS_JOB 서브 프로그램 14-14
작업 제출 14-15
작업 특성 변경 14-17
작업 실행, 제거 및 중단 14-18
제출한 작업의 정보 보기 14-19
DBMS_OUTPUT 패키지 사용 14-20
운영 체제 파일과의 상호 작용 14-21
UTL_FILE 패키지란? 14-22
UTL_FILE 패키지를 사용한 파일 처리 14-23
UTL_FILE 프로시저 및 함수 14-24
UTL_FILE 패키지 관련 예외 14-25
FOPEN 및 IS_OPEN 함수 14-26
UTL_FILE 사용 14-27
UTL_HTTP 패키지 14-29
UTL_HTTP 패키지 사용 14-30
UTL_TCP 패키지 사용 14-31
오라클 지원 패키지 14-32
요약 14-37
연습 14 개요 14-38
15 대형 객체 조작 n l y
목표 15-2
LOB 정의 15-3
e O
LONG 및 LOB 데이터 유형 대조 15-4
LOB 분석 15-5
U s
내부 LOB 15-6
내부 LOB 관리 15-7 A I
BFILE 정의 15-8
O
BFILE 보안 15-9
l &
새 데이터베이스 객체: DIRECTORY 15-10
a
DIRECTORY 객체 생성 지침 15-11
n
BFILE 관리 15-12
te
BFILE 사용 준비 15-13 r
I n
BFILENAME 함수 15-14
BFILE 로드 15-15
le
LONG에서 LOB으로 이전 15-17
c
DBMS_LOB 패키지 15-19
r a
DBMS_LOB.READ 및 DBMS_LOB.WRITE 15-22
O 테이블에 LOB 열 추가 15-23

LOB 열 채우기 15-24
SQL을 사용하여 LOB 갱신 15-26
PL/SQL에서 DBMS_LOB을 사용하여 LOB 갱신 15-27
SQL을 사용하여 CLOB 값 선택 15-28
x
DBMS_LOB을 사용하여 CLOB 값 선택 15-29
PL/SQL에서 CLOB 값 선택 15-30
LOB 제거 15-31
임시 LOB 15-32
임시 LOB 생성 15-33
요약 15-34
연습 15 개요 15-35
16 데이터베이스 트리거 작성
목표 16-2
트리거 유형 16-3
트리거 설계 지침 16-4
데이터베이스 트리거: 예제 16-5
DML 트리거 작성 16-6
DML 트리거 구성 요소 16-7
실행 시퀀스 16-11
DML 문장 트리거 작성 구문 16-13
DML 문장 트리거 작성 16-14
SECURE_EMP 테스트 16-15
조건부 술어 사용 16-16
DML 행(row) 트리거 작성 16-17 n l y
DML 행(row) 트리거 작성 16-18
OLD 및 NEW 수식자 사용 16-19
e O
OLD 및 NEW 수식자 사용: Audit_Emp_Table 사용 예제 16-20
행(row) 트리거 제한 16-21
U s
INSTEAD OF 트리거 16-22
INSTEAD OF 트리거 작성 16-23 A I
데이터베이스 트리거와 내장 프로시저 비교 16-28
O
트리거 관리 16-30
l &
데이터베이스 트리거와 Form Builder 트리거 비교 16-29
DROP TRIGGER 구문 16-31

n a
트리거 테스트 사례 16-32
te r
트리거 실행 모델 및 제약 조건 검사 16-33
I n
트리거 실행 모델 및 제약 조건 검사: 예제 16-34
패키지 생성자를 사용한 트리거 예제 데모 16-35
l e
After 행(row) 트리거와 After 문장 트리거 16-36
c
데모: VAR_PACK 패키지 명세(specification) 16-37
r a
요약 16-40
O 연습 16 개요 16-41
17 트리거 개념 추가 정보
목표 17-2
데이터베이스 트리거 작성 17-3
xi
DDL 문에 트리거 작성 17-4
시스템 이벤트에 대한 트리거 작성 17-5
LOGON 및 LOGOFF 트리거 예제 17-6
CALL 문 17-7
변경 테이블에서 데이터 읽기 17-8
변경 테이블: 예제 17-9
트리거 구현 17-11
서버 내 보안 제어 17-12
데이터베이스 트리거로 보안 제어 17-13
서버 기능을 사용하여 데이터 작업 감사 17-14
트리거를 사용하여 감사 17-15
서버 내 데이터 무결성 시행 17-16
트리거를 사용하여 데이터 무결성 보호 17-17
서버 내 참조 무결성 시행 17-18
트리거를 사용하여 참조 무결성 보호 17-19
서버 내 테이블 복제 17-20
트리거를 사용하여 테이블 복제 17-21
서버 내 파생 데이터 계산 17-22
트리거를 사용하여 파생 값 계산 17-23
트리거를 사용하여 이벤트 기록 17-24
데이터베이스 트리거의 장점 17-26
n l y
트리거 관리 17-27
트리거 정보 보기 17-28
e O
USER_TRIGGERS 사용 17-29
요약 17-31
U s
연습 17 개요 17-32
A I
18 종속성 관리
O
목표 18-2
종속성 이해 18-3
l &
종속성 18-4
n a
로컬 종속성 18-5
te
로컬 종속성 시나리오 18-7 r
I n
USER_DEPENDENCIES를 사용하여 직접 종속성 표시 18-8
직접 및 간접 종속성 표시 18-9
l e
종속성 표시 18-10
c
로컬 종속성의 다른 시나리오 18-11
r a
로컬 이름 지정 종속성의 시나리오 18-12
O 원격 종속성 이해 18-13
원격 종속성의 개념 18-15
REMOTE_DEPENDENCIES_MODE 파라미터 18-16
원격 종속성 모드 및 시간 기록 모드 18-17
xii
오전 8시에 원격 프로시저 B 컴파일 18-19
오전 9시에 로컬 프로시저 A 컴파일 18-20
프로시저 A 실행 18-21
오전 11시에 원격 프로시저 B 재컴파일 18-22
Signature 모드 18-24
PL/SQL 프로그램 단위 재컴파일 18-25
재컴파일 실패 18-26
재컴파일 성공 18-27
프로시저 재컴파일 18-28
패키지 및 종속성 18-29
요약 18-31
연습 18 개요 18-32
A 해답
B 테이블 설명 및 데이터
C Procedure Builder를 사용하여 프로그램 단위 작성
D REF 커서
인덱스
추가 연습
추가 연습 해답
n l y
추가 연습: 테이블 설명 및 데이터
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
xiii
n l y
e O
U s
A I
O
l &
na
te r
I n
c le
ra
O
xiv
머리말
n l y
e O
U s
A I
O
l &
na
te r
I n
c le
ra
O
n l y
e O
U s
A I
O
l &
na
te r
I n
c le
ra
O
프로파일
시작하기 전에
이 과정을 시작하기 전에 SQL, iSQL*Plus에 대해 자세히 알고 있어야 하며, 응용
프로그램 개발 경험이 있어야 합니다. 또한 Introduction to Oracle9i: SQL 또는
Introduction to Oracle9i for Experienced SQL Users 과정을 먼저 수강해야 합니다.
과정 구성
Oracle9i: Program with PL/SQL은 강사가 지도하는 과정으로서 강의와 실제적인 연습
문제로 구성됩니다. 온라인 데모와 연습 세션을 통해 소개된 개념 및 기술을
강화합니다.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
머리말-3
관련 서적
Oracle 참고 서적
제목 제품번호
Oracle9i Application Developer’s Guide-Fundamentals A88876-02
Oracle9i Application Developer’s Guide-Large Objects A88879-01
Oracle9i Supplied PL/SQL Packages and Type Reference A89852-02
PL/SQL User’s Guide and Reference A89856-01
참고 서적
y 시스템 릴리스 게시판
y 설치 및 사용 설명서
y read.me 파일
y International Oracle User’s Group (IOUG) articles
y Oracle Magazine
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
머리말-4
표기법
다음의 두 목록은 텍스트나 코드 안에 사용되는 표기법을 보여줍니다.
텍스트 안의 표기법
규칙 객체 또는 용어 예제
대문자 명령, 함수, SELECT 명령을 사용하여 EMPLOYEES
열 이름, 테이블의 LAST_NAME 열에 저장된
테이블 이름, 정보를 봅니다.
PL/SQL 객체,
스키마
소문자, 파일 이름, where: role is the name of the role
기울임꼴 구문 변수, to be created.
사용자 이름,
암호
머리 글자 트리거 및 ORD 블록에 When-Validate-Item
버튼 이름 트리거를 할당합니다.
Cancel을 선택합니다.
기울임꼴 책, 과정 및 주제에 대한 자세한 내용은
설명서 이름 Oracle9i Server SQL Language Reference
강조된 단어
또는 문
Manual을 참조하십시오.
데이터베이스 변경 내용은 저장하지 n l y

마십시오.
e O
따옴표 과정 안에서
참조되는
이 주제는 3과, “객체 사용”에서
다룹니다.
U s
학습 모듈 제목
A I
O
l &
n a
te r
I n
c le
r a
O
머리말-5
표기법(계속)
코드 안의 표기법
규칙 객체 또는 용어 예제
대문자 명령, 함수 SELECT userid
FROM emp;
소문자, 구문 변수 CREATE ROLE role;
기울임꼴
머리 글자 폼 트리거 Form module: ORD
Trigger level: S_ITEM.QUANTITY
item
Trigger name: When-Validate-Item
. . .
소문자 열 이름, . . .
테이블 이름, OG_ACTIVATE_LAYER
파일 이름, (OG_GET_LAYER
('prod_pie_layer'))
PL/SQL 객체 . . .
SELECT last_name
굵은체 사용자가
FROM emp;
DROP USER scott;
n l y
입력하는
텍스트
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
머리말-6
교과
과정표
n l y
e O
U s
A I
O
l &
na
te r
I n
c le
ra
O
n l y
e O
U s
A I
O
l &
na
te r
I n
c le
ra
O
Oracle9i 언어 과정
Introduction to Oracle9i: SQL for

Oracle9i: SQL 또는 Introduction to Oracle9i
for End Users
Introduction Oracle9i: Experienced SQL Users 강의실
to Oracle9i: Advanced
SQL Basics SQL
강의실
강의실

Oracle9i: PL/SQL Oracle9i: Develop PL/SQL
Fundamentals Program Units
강의실
Oracle9i: Advanced PL/SQL

강의실
n l y
Copyright © Oracle Corporation, 2001. All rights reserved.
e O
통합된 언어 과정
U s
Introduction to Oracle9i: SQL은 Introduction to Oracle9i: SQL Basics과 Oracle9i: Advanced
SQL의 두 개 모듈로 구성됩니다. Introduction to Oracle9i: SQL Basics에서는 데이터베이스
구조의 생성과 관계형 데이터베이스에서의 데이터 저장, 검색, 조작 방법을 다룹니다.
A I
O
Oracle9i: Advanced SQL에서는 고급 SELECT 문, Oracle SQL 및 iSQL*Plus Reporting을
다룹니다.
l &
관계형 데이터베이스에 대한 경험이 있으며 SQL에도 사전 지식이 있다면 Introduction to
a
Oracle9i for Experienced SQL Users가 적당합니다. 이 과정에서는 ANSI SQL에 속하지 않으며
n
오라클에 특정한 SQL 문에 대해 설명합니다.
te r
Oracle9i: Program with PL/SQL은 Oracle9i: PL/SQL Fundamentals와 Oracle9i: Develop PL/SQL
I n
Program Units의 두 개 모듈로 구성됩니다. Oracle9i: PL/SQL Fundamentals에서는 PL/SQL
언어 구조, 실행 흐름, SQL과의 인터페이스를 비롯한 PL/SQL의 기초적인 부분을 다룹니다.
l e
Oracle9i: Develop PL/SQL Program Units에서는 내장 프로시저, 함수, 패키지, 트리거를
c
작성하는 방법과 함께 PL/SQL 프로그램 코드를 유지 관리하고 디버깅하는 방법을 다룹니다.
r a
Oracle9i: SQL for End Users는 프로그래밍 관련 지식이 거의 없는 일반인을 대상으로 하는
O
과정으로 기본적인 SQL 문을 다룹니다. 이 과정은 기본적인 SQL 프로그래밍을 익히고자
하는 일반 사용자에게 적합합니다.
Oracle9i: Advanced PL/SQL은 PL/SQL 프로그래밍에 경험이 있는 일반인을 대상으로 하며
코드 효율성, 객체 지향 프로그래밍, 외부 코드를 사용한 작업, 오라클 지원 패키지의 고급
기능 등이 과정에서 다루는 내용입니다.
Oracle9i: Program with PL/SQL 교과 과정표 - 3
Oracle9i 언어 과정
Introduction to Oracle9i: SQL for

Oracle9i: SQL 또는 Introduction to Oracle9i
for End Users
Introduction Oracle9i: Experienced SQL Users 강의실
to Oracle9i: Advanced
SQL Basics SQL
강의실
강의실

Oracle9i: PL/SQL Oracle9i: Develop PL/SQL
Fundamentals Program Units
강의실

강의실
n l y
e O
통합된 언어 과정
U s
슬라이드에서는 언어 과정에서 제공하는 다양한 모듈과 교육 과정을 보여 줍니다. 아래의
표에서는 TBT에서 유사한 과정을 제공하는 모듈 및 과정을 소개합니다.
A I
과정 또는 모듈 TBT 과정
O
Introduction to Oracle9i: SQL
Basics
l &
Oracle SQL: Basic SELECT Statements
Oracle SQL: Data Retrieval Techniques
a
Oracle SQL: DML and DDL
n
Oracle9i: Advanced SQL
te rOracle SQL and SQL*Plus: Advanced SELECT Statements

Oracle SQL and SQL*Plus: SQL*Plus and Reporting
I
Experienced SQL Users n
Introduction to Oracle9i for Oracle SQL Specifics: Retrieving and Formatting Data
Oracle SQL Specifics: Creating and Managing Database Objects
c l e
Oracle9i: PL/SQL Fundamentals
Oracle9i: Develop PL/SQL
PL/SQL: Basics
PL/SQL: Procedures, Functions, and Packages
a
Program Units
r
Oracle9i: SQL for End Users
PL/SQL: Database Programming
SQL for End Users: Part 1
O
SQL for End Users: Part 2
Advanced PL/SQL: Implementation and Advanced Features
Advanced PL/SQL: Design Considerations and Object Types
Oracle9i: Program with PL/SQL 교과 과정표 - 4

PL/SQL 개요
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
과정 목표
이 과정을 마치면 다음을 수행할 수 있습니다.

y PL/SQL의 용도 설명
y DBA 및 개발자를 위한 PL/SQL 사용 방법 설명
y PL/SQL의 장점 설명
y 프로시저, 함수, 패키지, 데이터베이스 트리거의 작성,
실행 및 유지 관리
y PL/SQL 서브 프로그램 및 트리거 관리
y 오라클 지원 패키지 설명
y LOB(대형 객체) 조작
n l y
I-2 Copyright © Oracle Corporation, 2001. All rights reserved.
e O
단원 목표
U s
이 과정에서는 PL/SQL의 기능과 장점을 소개하고 PL/SQL을 사용해 데이터베이스에
액세스하는 방법을 배웁니다.
A I
다음과 같은 데이터베이스 객체를 사용하는 데이터베이스 프로시저로 모듈식 응용 프로그램을
개발할 수 있습니다. O
y 프로시저 및 함수
l &
y 패키지
n a
y 데이터베이스 트리거
모듈식 응용 프로그램은 다음을 향상시킵니다.
te r
y 기능성 I n
y 보안
c l e
y
r a
전체 성능
O
Oracle9i: Program with PL/SQL I-2
PL/SQL
y PL/SQL은 SQL에 프로그래밍 언어 설계 기능을

절차적으로 추가한 것입니다.
y SQL의 데이터 조작문 및 질의문은 프로시저 단위
코드에 포함됩니다.
n l y
e O
PL/SQL
U s
PL/SQL은 관계형 데이터베이스에 대한 표준 데이터 액세스 언어인 SQL에 오라클의 절차적
언어를 추가한 것입니다. PL/SQL은 데이터 캡슐화, 예외 처리, 정보 숨김, 객체 지향 등과 같은
현대 소프트웨어 공학 기능을 제공하여 Oracle Server 및 툴세트에 최신 프로그래밍 기능을 A I
추가합니다. O
l &
PL/SQL은 1970년대와 1980년대에 설계된 프로그래밍 언어의 다양한 고급 기능을 포함합니다.
n a
PL/SQL은 SQL의 데이터 조작문 및 질의문을 블록 구조 및 프로시저 단위 코드에 포함시킬 수
있는 강력한 트랜잭션 처리 언어입니다. PL/SQL을 사용하면 SQL 문으로 오라클 데이터를
r
처리하고 PL/SQL 제어문으로 데이터를 처리할 수 있습니다.
te
I n
c le
r a
O
PL/SQL 환경
PL/SQL 엔진
PL/SQL
PL/SQL PL/SQL 프로시저문
블록 블록 SQL 실행자
SQL 문 실행자
Oracle server
n l y
e O
PL/SQL 환경
U s
PL/SQL은 소유권의 측면에서 볼 때 오라클 제품이 아니고 Oracle Server 및 특정 오라클 툴에서
사용되는 기술입니다. PL/SQL 블록은 클라이언트 툴 또는 Oracle Server 내에 있는 PL/SQL
엔진에 전달되어 처리됩니다. PL/SQL을 호출하는 위치에 따라 다른 엔진이 사용됩니다. A I
O
Pro*C 또는 Pro*Cobol 프로그램, 사용자 종료, iSQL*Plus 또는 Server Manager 등의 오라클 선행
l &
컴파일러에서 PL/SQL 블록을 제출하면 Oracle Server 내의 PL/SQL 엔진이 PL/SQL 블록을
a
처리합니다. PL/SQL 엔진은 SQL 문을 분리하여 하나씩 SQL 문 실행자로 전송합니다.
n
te r
응용 프로그램에서 Oracle Server로 블록을 전송할 때 단일 전송이 사용되므로 성능이
향상됩니다(특히 클라이언트-서버 네트워크의 경우). PL/SQL 코드는 또한 데이터베이스에
연결된 응용 프로그램이 그 수에 관계없이 참조할 수 있는 서브 프로그램의 형태로 Oracle
I n
Server에 저장할 수 있습니다.
c l e
r a
O
PL/SQL의 장점
통합
응용 프로그램
Oracle server
공유
라이브러리
n l y
e O
PL/SQL의 장점
U s
통합
PL/SQL은 Oracle Server(내장 프로시저, 내장 함수, 데이터베이스 트리거, 패키지를 통해) 및
A I
오라클 개발 툴(Oracle Developer 구성 요소 트리거를 통해) 모두에서 중심적인 역할을 합니다.
O
Oracle Forms Developer, Oracle Reports Developer 및 Oracle Graphics Developer 응용 프로그램은,
l &
코드(프로시저 및 함수)를 보유하며 로컬 또는 원격으로 액세스할 수 있는 공유 라이브러리를
사용합니다.
n a
te r
SQL 데이터 유형도 PL/SQL에서 사용할 수 있습니다. 이러한 데이터 유형의 공유는 SQL에서
제공하는 직접 액세스 기능과 함께 PL/SQL을 Oracle Server 데이터 딕셔너리에 통합합니다.
PL/SQL은 절차적인 프로그래밍 기능을 이용하면서 동시에 데이터베이스에 쉽게 액세스할 수
있도록 합니다.
I n
c l e
오라클 툴에 사용되는 PL/SQL
Oracle Developer와 같은 오라클 툴에는 Oracle Server에 있는 엔진과는 별도의 PL/SQL 엔진이
r
있습니다.
a
O
이 엔진은 SQL 문을 필터링하여 Oracle Server의 SQL 문 실행자에 하나씩 보내며 나머지
프로시저문은 PL/SQL 엔진에 있는 프로시저문 실행자에서 처리합니다.
프로시저문 실행자는 데이터베이스가 아닌 클라이언트 환경에 있는 즉, 응용 프로그램에 대해
로컬인 데이터를 처리합니다. 따라서 Oracle Server에 전달되는 작업과 필요한 메모리 커서 수가
줄어듭니다.

PL/SQL의 장점
성능 향상
SQL
응용 SQL
기타 DBMS
프로그램 SQL
SQL
SQL
IF...THEN PL/SQL을
응용 SQL
ELSE 사용하는
프로그램 SQL 오라클
END IF;
SQL
n l y
e O
PL/SQL의 장점(계속)
U s
성능 향상
PL/SQL은 응용 프로그램의 성능을 개선합니다. 성능 개선의 정도는 실행 환경에 따라 다릅니다.
A I
y PL/SQL을 사용하면 SQL 문을 하나의 블록으로 그룹화하여 한 번의 호출로 블록 전체를
O
l &
서버에 보낼 수 있으므로 네트워크 통신량을 줄일 수 있습니다. 그러나 PL/SQL을 사용하지
않으면 SQL 문이 한 번에 하나씩 Oracle Server에 보내지는데, 이때 각 SQL 문이 Oracle
a
Server에 별도의 호출을 발생시켜 성능 오버헤드가 증가합니다. 네트워크 환경에서는
n
te r
오버헤드가 중요한 문제입니다. 슬라이드에서와 같이 SQL이 많이 사용되는 응용
프로그램의 경우에는 PL/SQL 블록 및 서브 프로그램을 사용하여 SQL 문을 그룹화한 후
Oracle Server에 보내 실행할 수 있습니다.
y
I n
Oracle Forms 및 Oracle Reports와 같은 Oracle Server 응용 프로그램 개발 툴에서도
l e
PL/SQL을 사용할 수 있습니다. PL/SQL은 이러한 툴에 절차적 처리 기능을 추가하여
c
성능을 향상시킵니다.
r a
참고: Oracle Forms 또는 Reports Developer 응용 프로그램의 일부로 선언되는 프로시저 및 함수는
O
데이터베이스에 저장된 프로시저 및 함수와 일반 구조는 동일하지만 뚜렷하게 구별됩니다. 내장
서브 프로그램은 데이터 딕셔너리에 저장되는 데이터베이스 객체로서 Oracle Forms 또는 Reports
Developer 응용 프로그램을 비롯한 여러 응용 프로그램에서 액세스할 수 있습니다.

PL/SQL의 장점
모듈식 프로그램 개발
…
DECLARE
…
BEGIN
…
EXCEPTION
END;
n l y
e O
U s
SQL에서는 제공하지 않는 PL/SQL의 절차적 기능을 활용할 수 있습니다.
PL/SQL 블록 구조
A I
모든 PL/SQL 단위는 하나 이상의 블록으로 구성됩니다. 이 블록은 완전히 분리되거나 다른 블록
O
l &
안에 중첩될 수 있습니다. PL/SQL 프로그램을 구성하는 기본 단위(프로시저, 함수 및 익명
블록)는 논리적 블록입니다. 논리적 블록에는 여러 개의 중첩된 서브 블록이 포함될 수 있습니다.
a
따라서 한 블록이 다른 블록의 일부이고 이 블록이 다시 전체 코드 단위의 일부일 수 있습니다.
n
모듈식 프로그램 개발
y
te r
논리적으로 연관된 명령문들을 블록으로 그룹화합니다.
y I n
서브 블록을 더 큰 블록에 중첩시켜 강력한 프로그램을 구축합니다.
y
c le
복잡한 문제를 관리가 편리하고 잘 정의된 논리적 모듈 집합으로 나누고 모듈을 블록으로
y r a
구현합니다.
재사용 가능한 PL/SQL 코드를 Oracle Form과 Oracle Reports 응용 프로그램이 공유하는
O 라이브러리에 넣거나 Oracle Server에 저장하면 오라클 데이터베이스와 상호 작용할 수
있는 모든 응용 프로그램이 액세스할 수 있습니다.

PL/SQL의 장점
y PL/SQL은 이식 가능합니다.
y 변수를 선언할 수 있습니다.
n l y
e O
U s
이식성
y
A
PL/SQL은 Oracle Server에 고유하기 때문에 Oracle Server와 PL/SQL을 지원하는 모든 I
호스트 환경(운영 체제 또는 플랫폼)으로 프로그램을 옮길 수 있습니다. 즉 PL/SQL
프로그램은 Oracle Server를 실행할 수 있는 모든 환경에서 실행할 수 있으므로 매번 O
새 환경에 맞출 필요가 없습니다.
l &
y
a
또한 Oracle Server와 응용 프로그램 간에 코드를 이동할 수 있기 때문에 이식 가능한
n
식별자:
te r
프로그램 패키지와 다른 환경에서 재사용할 수 있는 라이브러리를 작성할 수 있습니다.
I n
PL/SQL에서 식별자는 다음과 같은 작업에 사용됩니다.
y
y
c l e
변수, 커서, 상수 및 예외를 선언한 다음 SQL 문과 프로시저문에서 사용할 수 있습니다.
스칼라, 참조, 조합 및 LOB(대형 객체) 데이터 유형에 속한 변수를 선언합니다.
y
r a
데이터베이스 테이블 및 열의 데이터 구조를 기반으로 하여 변수를 동적으로 선언할 수
O 있습니다.

PL/SQL의 장점
y 절차적 언어 제어 구조로 프로그래밍할 수 있습니다.

y PL/SQL은 오류를 처리할 수 있습니다.
n l y
e O
U s
절차적 언어 제어 구조:
절차적 언어 제어 구조를 통해 다음을 수행할 수 있습니다.
A I
y 명령문 시퀀스를 조건에 따라 실행합니다.
O
y 명령문 시퀀스를 루프에서 반복적으로 실행합니다.
l &
y
a
명시적(explicit) 커서를 이용하여 여러 행 질의가 반환한 행(row)을 하나씩 처리합니다.
n
오류:
te r
PL/SQL의 오류 처리 기능을 통해 다음을 수행할 수 있습니다.
y
I n
Oracle Server 오류를 예외 처리 루틴으로 처리합니다.
y
l e
사용자 정의 오류 조건을 선언하고 예외 처리 루틴으로 처리합니다.
c
r a
O
서브 프로그램의 장점
y 손쉬운 유지 관리
y 데이터 보안 및 무결성 향상
y 성능 향상
y 코드 명확성 향상
n l y
e O
U s
내장 프로시저와 함수를 이용하면 응용 프로그램 개발의 모듈화 외에도 많은 이점을 얻을 수
있습니다.
A I
y 유지 관리가 간단하여 다음과 같은 작업이 가능합니다.
− 다른 사용자를 방해하지 않고도 온라인으로 루틴을 수정할 수 있습니다. O
−
l
루틴 하나만 수정하여 여러 응용 프로그램에 영향을 줄 수 있습니다.&
−
a
테스트를 반복하지 않아도 되도록 루틴 하나만 수정할 수 있습니다.
n
y 다음을 통해 데이터 보안 및 무결성이 개선됩니다.
−
te r
보안 권한을 통해 권한이 없는 사용자의 데이터베이스 객체에 대한 간접 액세스를
−
제어합니다.
I n
단일 경로를 통해 관련 테이블에 대한 작업을 한 곳으로 모아 관련 작업이 함께
y
c le
수행되거나 전혀 수행되지 않도록 합니다.
성능 향상을 통해 다음을 수행할 수 있습니다.
r − a
공유 SQL 영역을 활용하여 여러 사용자가 사용하는 구문을 재분석하지 않도록
O −
합니다.
컴파일 시에 PL/SQL의 구문을 분석하여 실행 중에 분석되지 않도록 합니다.
− 명령을 묶어 데이터베이스에 대한 호출 수를 줄이고 네트워크 통신량을 줄입니다.
y 코드 명확성 향상: 루틴의 작업을 나타내는 적절한 식별자 이름을 사용하여 주석 사용의
필요를 줄이고 코드의 명확성을 향상시킵니다.
내장 프로시저 및 함수 호출
Scott LOG_EXECUTION
프로시저
1 xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
2
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
3 vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
xxxxxxxxxxxxxx vvvvvvvvvvvvvv
Oracle Oracle Oracle vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
Portal Discoverer Forms vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
Developer vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
4
Scott
n l y
e O
내장 프로시저 및 함수 호출 방법
U s
Portal, 기타 내장 프로시저, 그리고 여러 오라클 툴 및 선행 컴파일러 응용 프로그램 등과 같은
다양한 환경에서 호출할 수 있습니다. 다음 표에서는 이전에 작성한 프로시저인 A I
이전에 작성한 프로시저나 함수를 iSQL*Plus, Oracle Forms Developer, Oracle Discoverer, Oracle
log_execution을 다양한 환경에서 호출하는 방법을 설명합니다. O

iSQL*Plus
l &
EXECUTE log_execution
Oracle Forms Developer와

n a
log_execution;
같은 오라클 개발 툴
다른 프로시저
te r
CREATE OR REPLACE PROCEDURE leave_emp
I n (p_id IN employees.employee_id%TYPE)
IS
c l e BEGIN
DELETE FROM employees
WHERE employee_id = p_id;
r a log_execution;
END
O leave_emp;

요약
y PL/SQL은 SQL을 확장한 것입니다.
y PL/SQL 코드 블록은 PL/SQL 엔진으로 전달되어
처리됩니다.
y PL/SQL의 장점:
– 통합
– 성능 향상
– 이식성
– 프로그램 개발의 모듈화
y 서브 프로그램은 프로시저 또는 함수로 선언되는
이름이 지정된 PL/SQL 블록입니다.
y 서브 프로그램은 여러 환경에서 호출할 수 있습니다.
n l y
e O
요약
U s
PL/SQL은 SQL이 확장된, 프로그래밍 기능을 가진 언어입니다. PL/SQL을 이용하면 구성의
흐름을 제어할 수 있으며 변수를 선언 및 사용할 수 있습니다. PL/SQL 응용 프로그램은 오라클이
실행되는 모든 플랫폼 또는 운영 체제에서 실행할 수 있습니다. A I
이름이 지정된 PL/SQL은 서브 프로그램 또는 프로그램 단위라고 합니다. 프로시저, 함수, 패키지 O
l
및 트리거는 PL/SQL 생성자입니다. 서브 프로그램은 여러 환경에서 호출할 수 있습니다.
&
n a
te r
I n
c le
r a
O
변수 선언
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표
이 단원을 마치면 다음을 수행할 수 있습니다.

y 기본 PL/SQL 블록과 각 부분에 대한 이해
y PL/SQL에서의 변수 의미 설명
y PL/SQL 변수 선언
y PL/SQL 블록 실행
n l y
1-2 Copyright © Oracle Corporation, 2001. All rights reserved.
e O
단원 목표
이 단원에서는 PL/SQL 코드 블록의 작성 및 실행에 대한 기본 규칙과 구조, 그리고 변수의 선언 및
U s
데이터 유형 할당 방법을 설명합니다.
A I
O
l &
n a
te r
I n
c le
ra
O
Oracle9i: Program with PL/SQL 1-2

DECLARE (선택사항)
변수, 커서, 사용자 정의 예외 사항
BEGIN (필수사항)
– SQL 문
– PL/SQL 문
EXCEPTION (선택 사항)
오류가 발생할 때 수행할 작업
END; (필수사항)
…
DECLARE
…
BEGIN
…
EXCEPTION
END;
n l y
e O
PL/SQL은 프로그램을 논리적 블록으로 분리할 수 있는 블록 구조 언어입니다. PL/SQL 블록은
U s
선언 부분(선택사항), 실행 부분(필수사항) 및 예외 처리 부분(선택사항)의 최대 세 부분으로
구성됩니다. 다음 표는 이 세 부분에 대한 설명입니다. A I
O
부분 설명
l& 포함 여부
na
선언 실행 및 선언 부분에서 참조하는 모든 변수, 상수, 선택사항
r
커서 및 사용자 정의 예외 사항을 포함합니다.
e
nt
실행 데이터베이스의 데이터를 조작하기 위한 SQL 필수사항
e I문과 블록의 데이터를 조작하기 위한 PL/SQL

문을 포함합니다.
예외 처리
c l 실행 부분에서 오류 및 비정상 조건이 발생할 때 선택사항
ra 수행할 작업을 지정합니다.

명령문 및 PL/SQL 블록 실행
DECLARE
v_variable VARCHAR2(5);
BEGIN
SELECT column_name
INTO v_variable
FROM table_name;
EXCEPTION
WHEN exception_name THEN
...
END;
…
DECLARE
…
BEGIN
…
EXCEPTION
END;
n l y
e O
명령문 및 PL/SQL 블록 실행
y SQL 문 또는 PL/SQL 제어문 끝에 세미콜론(;)을 입력합니다.
U s
y 처리되지 않은 오류 또는 컴파일 오류 없이 블록이 성공적으로 실행되면, 다음과 같은
A I
메시지가 출력됩니다.
O
l &
n a
te r
y 섹션 키워드 DECLARE, BEGIN 및 EXCEPTION 뒤에는 세미콜론(;)이 사용되지 않습니다.
y END 및 모든 다른 PL/SQL 문에는 명령문을 종결하기 위한 세미콜론(;)이 있어야 합니다.
I n
y 한 행에 여러 명령문을 입력할 수는 있지만, 명확성이나 편집 작업을 고려할 때 이 방법은
le
사용하지 않는 것이 좋습니다.
c
r a
참고: PL/SQL에서는 오류를 예외(exception)라고 합니다.
모듈화를 통해 응용 프로그램을 관리가 용이하고 잘 정의된 여러 개의 모듈로 나눌 수 있습니다.
O
이런 지속적 분리를 통해 복잡한 문제를 손쉽게 구현 가능한 솔루션을 가진 단순한 문제의
묶음으로 정리할 수 있습니다. PL/SQL은 블록, 서브 프로그램 및 패키지를 비롯한 프로그램 단위를
통해 이러한 요구를 충족시킵니다.

블록 유형
익명 프로시저 함수
[DECLARE] PROCEDURE name FUNCTION name
IS RETURN datatype
IS
BEGIN BEGIN BEGIN
--statements --statements --statements
RETURN value;
[EXCEPTION] [EXCEPTION] [EXCEPTION]
END; END; END;
n l y
e O
블록 유형
PL/SQL 프로그램은 하나 이상의 블록으로 구성됩니다. 이러한 블록은 완전히 별개일 수도 있고
U s
다른 블록 내에 중첩될 수도 있습니다. PL/SQL 프로그램을 구성하는 기본 단위인 프로시저와
함수(서브 프로그램과 익명 블록이라고도 함)는 여러 개의 중첩된 서브 블록이 포함될 수 있는
A I
논리적 블록입니다. 따라서 한 블록은 다른 블록의 일부인 동시에 전체 코드 단위의 일부가 될 수
O
있습니다.
익명 블록
l &
n a
익명 블록은 이름이 지정되지 않은 블록으로, 응용 프로그램의 실행 부분에서 선언되어 실행 중에
te r
PL/SQL 엔진에 전달됩니다. 익명 블록은 선행 컴파일러 프로그램 및 iSQL*Plus 또는 Server
Manager에 포함될 수 있습니다. Oracle Developer 구성 요소의 트리거는 이러한 익명 블록으로
구성됩니다.
서브 프로그램 I n
c le
서브 프로그램은 파라미터를 사용할 수 있는 이름이 지정된 PL/SQL 블록이며 호출할 수 있습니다.
r a
서브 프로그램은 프로시저 또는 함수로 선언할 수 있습니다. 일반적으로 프로시저는 작업을
수행하는 데 사용하고 함수는 값을 계산하는 데 사용합니다.
O
서브 프로그램을 서버 또는 응용 프로그램 레벨로 저장할 수 있습니다. Oracle Developer 구성
요소(Forms, Reports, Graphics)를 사용하면 프로시저 및 함수를 응용 프로그램의 일부(폼 또는
보고서)로 선언하여 필요한 경우 동일한 응용 프로그램의 다른 프로시저, 함수 및 트리거(다음
페이지 참조) 등에서 호출할 수 있습니다.
참고: 함수는 반드시 값을 반환해야 한다는 점을 제외하면 프로시저와 동일합니다.

프로그램 생성자
…
DECLARE
…
BEGIN
…
EXCEPTION
END;
툴 생성자 데이터베이스 서버
익명 블록 생성자
응용 프로그램 프로시저 또는 익명 블록
함수 내장 프로시저 또는 함수
응용 프로그램 패키지 내장 패키지
응용 프로그램 트리거 데이터베이스 트리거
객체 유형 객체 유형
n l y
e O
프로그램 생성자
다음 표에서는 기본 PL/SQL 블록을 사용하는 다양한 PL/SQL 프로그램 생성자를 간략하게
U s
설명합니다. 실행 환경에 따라 사용 가능한 프로그램 생성자가 다릅니다.
A I
프로그램 생성자 설명
익명 블록 응용 프로그램에 포함되거나 대화식으로 실행되는, O 사용 가능 환경
모든 PL/SQL 환경
이름이 지정되지 않은 PL/SQL 블록
l &
응용 프로그램
프로시저 또는
n
라이브러리에 저장된, 이름이 지정된 PL/SQL 블록으로 a
Oracle Forms Developer 응용 프로그램 또는 공유 Oracle Forms Developer,
Oracle Reports 등과 같은
함수
r
파라미터의 사용 및 이름을 사용한 반복 호출 가능
te
Oracle Developer 툴 구성
요소
내장 프로시저 또
는 함수 I n
Oracle server에 저장된, 이름이 지정된 PL/SQL 블록으로
파라미터의 사용 및 이름을 사용한 반복 호출 가능
Oracle server
패키지
(응용 프로그램 cl e Oracle Forms Developer
연관된 프로시저, 함수 및 식별자를 그룹화한 이름이
지정된 PL/SQL 모듈 등과 같은 Oracle server
또는 내장)
r a 및 Oracle Developer 툴
데이터베이스
트리거
O 트리거될 때 자동 실행되는 PL/SQL 블록
구성 요소
데이터베이스 테이블과 연결되어 있으며 DML 문에 의해 Oracle server
응용 프로그램 트 응용 프로그램 이벤트와 연결되어 있으며 자동 실행되는 Oracle Forms Developer 등

리거 PL/SQL 블록 과 같은 Oracle Developer
툴 구성 요소
객체 유형 데이터 구조를 데이터 조작에 필요한 함수 및 프로시저와 Oracle server와 Oracle
함께 캡슐화한 사용자 정의된 조합 데이터 유형 Developer 툴
변수 사용
변수가 사용되는 작업:

y 데이터 임시 저장
y 저장된 값 조작
y 재사용성
n l y
e O
변수 사용
PL/SQL에서는 변수를 선언한 후에, 표현식을 사용할 수 있는 SQL 및 프로시저문에서 변수를
U s
사용할 수 있습니다. 변수는 다음 작업에 사용될 수 있습니다.
A I
O
y 데이터 임시 저장: 데이터를 하나 이상의 변수에 임시로 저장해 두었다가 입력 데이터 검증에
이용하거나 데이터 흐름 프로세스의 후반 과정에 처리할 수 있습니다.
l &
y 저장된 값 조작: 변수는 데이터베이스에 액세스하지 않은 채 계산 및 기타 데이터 조작에 사
용할 수 있습니다.
n a
te r
y 재사용성: 변수를 선언한 후에는 선언문을 비롯한 다른 명령문에서 변수를 참조하기만 하면
응용 프로그램에서 여러 번 사용할 수 있습니다.
I n
y 손쉬운 유지 관리: %TYPE과 %ROWTYPE (%ROWTYPE에 대한 자세한 내용은 다음 단원 참조)을
사용하면 데이터베이스 열의 정의를 기반으로 변수를 선언할 수 있습니다. 기본 정의가
le
변경되면 변수 선언도 그에 따라 실행 중에 변경됩니다. 이는 데이터 독립성을 제공하고,
c
유지 관리 비용을 줄여주며, 프로그램이 새로운 비즈니스 요구에 따른 데이터베이스의
r a
변경을 수용할 수 있게 합니다. %TYPE에 대한 자세한 내용은 이 단원의 뒷부분에서
다룹니다.
O

PL/SQL에서 변수 처리
y 선언 부분에서 변수를 선언하고 초기화합니다.

y 실행 부분에서 변수에 새 값을 할당합니다.
y 파라미터를 통해 값을 PL/SQL 블록에 전달합니다.
y 출력 변수를 통해 결과를 봅니다.
n l y
e O
PL/SQL에서 변수 처리
선언 부분에서 변수 선언 및 초기화
U s
PL/SQL 블록이나 서브 프로그램 또는 패키지의 선언 부분에서 변수를 선언할 수 있습니다. 선언은
A I
값이 저장될 저장 공간을 할당하고, 데이터 유형을 지정하며, 저장 위치에 이름을 붙여 참조할 수
O
있도록 합니다. 또한 선언에서 변수에 초기값을 할당하고 NOT NULL 제약 조건을 줄 수 있습니다.
선언해야 합니다.
l &
사전 참조는 허용되지 않습니다. 변수는 선언문을 비롯한 다른 명령문에서 참조하기 전에
실행 부분에서 변수에 새 값 할당
n a
te r
실행 부분에서는, 변수의 기존 값이 변수에 새로 할당된 값으로 바뀝니다.
I n
파라미터를 통해 값을 PL/SQL 서브 프로그램에 전달
파라미터 모드에는 IN (기본값), OUT, IN OUT이 있습니다. IN 파라미터는 호출되는 서브
le
프로그램에 값을 전달할 때 사용되며, OUT 파라미터는 서브 프로그램의 호출자에게 값을 반환할
c
때 사용됩니다. IN OUT 파라미터는 호출되는 서브 프로그램에 초기값을 전달하고 호출자에게
ra
갱신된 값을 반환할 때 사용됩니다. 익명 블록에 값을 전달할 때는 iSQL*PLUS 치환 변수를
사용합니다.
O
참고: 출력 변수를 통해 PL/SQL 블록의 결과를 보는 방법은 이 단원의 뒷부분에서 설명합니다.

변수 유형
y PL/SQL 변수:
– 스칼라
– 조합
– 참조
– LOB (대형 객체)
y 비 PL/SQL 변수: 바인드 및 호스트 변수
n l y
e O
변수 유형
모든 PL/SQL 변수는 저장 형식, 제약 조건 및 유효한 값의 범위를 지정하는 데이터 유형을 가지고
U s
있습니다. PL/SQL은 스칼라, 조합, 참조, LOB (대형 객체)의 네 가지 데이터 유형을 지원하며
이러한 데이터 유형은 변수, 상수 및 포인터 선언에 사용할 수 있습니다. A I
O
y 스칼라 데이터 유형은 단일 값을 보유합니다. 기본 데이터 유형은 Oracle server 테이블의 열
유형에 대응됩니다. PL/SQL은 부울 변수도 지원합니다.
l &
합니다.
n a
y 레코드와 같은 조합 데이터 유형은 필드 그룹을 PL/SQL 블록에서 정의하고 조작할 수 있도록
te r
y 참조 데이터 유형은 다른 프로그램 항목을 지정하는 값 즉, 포인터를 보유합니다. 이
과정에서는 참조 데이터 유형을 다루지 않습니다.
I n
y LOB 데이터 유형은 용량이 큰 대형 객체(그래픽 이미지 등)의 위치를 지정하는 값(위치자)을
l e
보유합니다. LOB 데이터 유형은 이 단원 뒷부분에서 자세히 설명합니다.
c
비 PL/SQL 변수에는 선행 컴파일러 프로그램에 선언된 호스트 언어 변수, Forms 응용 프로그램의
r a
화면 필드 및 iSQL*Plus 호스트 변수가 포함됩니다.
O
LOB에 대한 자세한 내용은 PL/SQL User's Guide and Reference, “Fundamentals”를 참조하십시오.

PL/SQL 블록 내에 iSQL*Plus 변수 사용
y PL/SQL에는 자체 입력 또는 출력 기능이 없습니다.
y 앰퍼샌드를 접두어로 붙이면 PL/SQL 블록 내에서 치환

변수를 참조할 수 있습니다.
y iSQL*Plus 호스트(또는 “바인드”) 변수를 사용하면

런타임 값을 PL/SQL 블록에서 iSQL*Plus 환경으로
다시 전달할 수 있습니다.
n l y
e O
PL/SQL 블록 내에 iSQL*Plus 변수 사용
PL/SQL에는 자체 입/출력 기능이 없습니다. 따라서 PL/SQL 블록과 값을 주고 받는 작업은 PL/SQL
U s
블록의 실행 환경에 따라 달라집니다.
A I
O
iSQL*Plus 환경에서는, iSQL*Plus 치환 함수를 사용해 런타임 값을 PL/SQL 블록으로 전달할 수
있습니다. SQL 문에서 iSQL*Plus 치환 변수를 참조하는 것과 동일한 방식으로 앰퍼샌드를
l &
접두어로 사용하여 PL/SQL 블록 내에서 치환 변수를 참조할 수 있습니다. 텍스트 값은 PL/SQL
블록이 실행되기 전에 PL/SQL 블록으로 치환됩니다. 따라서 루프를 이용하여 치환 변수의 값을
다른 값으로 치환할 수 없습니다.
n a
te r
iSQL*Plus 호스트 변수를 사용하면 런타임 값을 PL/SQL 블록에서 iSQL*Plus 환경으로 다시 전달할
수 있습니다. 콜론을 접두어로 사용하여 PL/SQL 블록에서 호스트 변수를 참조할 수 있습니다.
I n
바인드 변수에 대해서는 이 단원의 뒷부분에서 자세히 설명합니다.
c le
ra
O

변수 유형
25-JAN-01
TRUE
“87년 전 우리의 선조는 이 대륙에, 자유
속에서 태어난, 그리고 만민이 평등하게

창조되었다는 신조에 모든 것을 바친
256120.08 새 나라를 건설하였습니다.”
Atlanta
n l y
e O
변수 유형
이 슬라이드는 다음과 같은 변수 데이터 유형을 보여줍니다.
U s
y TRUE의 데이터 유형은 부울입니다.
A I
y 25-JAN-01의 데이터 유형은 DATE입니다.
O
y 사진의 데이터 유형은 BLOB입니다.
y 연설 텍스트의 데이터 유형은 LONG입니다.
l &
n a
y 256120.08의 데이터 유형은 전체 자릿수 및 소수점 이하 자릿수를 나타내는 NUMBER입니다.
te
y 영화의 데이터 유형은 BFILE입니다. r
n
y 도시 이름의 데이터 유형은 VARCHAR2입니다.
I
c le
ra
O

PL/SQL 변수 선언
구문:
identifier [CONSTANT] datatype [NOT NULL]
[:= | DEFAULT expr];
예제:
DECLARE
v_hiredate DATE;
v_deptno NUMBER(2) NOT NULL := 10;
v_location VARCHAR2(13) := 'Atlanta';
c_comm CONSTANT NUMBER := 1400;
n l y
e O
PL/SQL 변수 선언
PL/SQL 블록에서 PL/SQL 식별자를 참조하려면 먼저 선언 부분에서 모든 PL/SQL 식별자를
U s
선언해야 합니다. 변수의 초기값은 선택적으로 할당할 수 있습니다. 따라서 변수를 선언할 때
반드시 변수에 값을 할당하지 않아도 됩니다. 선언 부분에서 다른 변수를 참조하는 경우에는 이전 A I
명령문에서 해당 변수를 따로 선언해야 합니다.
O
구문 설명:
l &
identifier 변수 이름입니다.
n a
CONSTANT
te r
변수의 값을 변경할 수 없도록 제한합니다. 상수는 반드시
초기화해야 합니다.
data type
e In 스칼라, 조합, 참조 또는 LOB 데이터 유형이 사용됩니다.

(이 과정에서는 스칼라, 조합 및 LOB 데이터 유형만
c l 설명합니다.)
O
expr
ra
NOT NULL 변수에 값이 반드시 포함되도록 제한합니다. (NOT NULL
변수는 반드시 초기화해야 합니다.)
PL/SQL 표현식으로, 리터럴 표현식, 다른 변수 또는
연산자 및 함수를 포함하는 표현식이 모두 가능합니다.

PL/SQL 변수 선언 지침
y 이름 지정 규칙을 따릅니다.
y NOT NULL 및 CONSTANT로 지정된 변수를
초기화합니다.
y 한 행에 하나의 식별자를 선언합니다.
y 할당 연산자(:=) 또는 DEFAULT 예약어를 사용하여
식별자를 초기화합니다.
identifier := expr;
n l y
e O
PL/SQL 변수 선언 지침
U s
다음은 PL/SQL 변수를 선언할 때 따라야 할 지침입니다.
y SQL 객체에 사용하는 규칙과 동일한 규칙에 따라 식별자 이름을 지정합니다.
A I
y 이름 지정 규칙을 사용할 수 있습니다(예: 변수를 나타내는 v_name, 상수 변수를 나타내는
O
c_name).
y NOT NULL 제약 조건을 사용한 경우에는 값을 반드시 할당해야 합니다.
l &
n a
y 식별자를 한 행에 하나씩 선언하면 코드를 읽고 유지 관리하기가 쉬워집니다.
te r
y 상수를 선언할 때는 유형 지정자 앞에 CONSTANT 키워드를 접두어로 붙여야 합니다. 아래의
선언에서는 NUMBER의 서브 유형인 REAL 상수에 이름을 지정하고 값 50000을 할당합니다.
I n
선언 부분에서 상수를 초기화하지 않으면 선언을 구성(컴파일)할 때 컴파일 오류가
발생합니다.
v_sal
c l e
CONSTANT REAL := 50000.00;
r a
y 할당 연산자(:=) 또는 DEFAULT 예약어를 사용한 표현식으로 변수를 초기화합니다. 초기값이
할당되지 않은 새 변수는 기본적으로 나중에 값이 할당될 때까지 NULL 값을 가집니다.
O
변수에 값을 할당 또는 재할당하려면 PL/SQL 할당문을 작성합니다. 변수 이름은 할당
연산자(:=)의 왼쪽에 새 값이 오도록 명시적으로(explicitly) 지정해야 합니다. 모든 변수를
초기화하는 것이 좋은 프로그래밍 습관입니다.

이름 지정 규칙
y 서로 다른 블록에 있는 두 변수는 동일한 이름을 가질 수
있습니다.
y 변수 이름(식별자)은 블록에서 사용되는 테이블 열의
이름과 동일하면 안됩니다.
DECLARE
employee_id NUMBER(6);
BEGIN PL/SQL 식별자에
SELECT employee_id 이름 지정 규칙을
INTO employee_id
FROM employees 적용합니다.
WHERE last_name = 'Kochhar'; 예, v_employee_id
END;
/
n l y
e O
서로 다른 블록에서 정의된 두 객체의 이름은 같을 수 있습니다. 하지만 같은 이름의 두 변수가
U s
동일한 블록에 존재하는 경우에는 현재 블록에서 선언한 객체만 사용할 수 있습니다.
A I
블록에서 사용되는 테이블 열의 이름과 동일한 변수 이름(식별자)을 사용하면 안됩니다. SQL 문에
있는 PL/SQL 변수의 이름이 열의 이름과 동일하면, Oracle server는 변수를 참조되는 열로 O
l &
간주합니다. 슬라이드 예제 코드의 경우, 사용할 수는 있지만 코드를 작성할 때 데이터베이스
테이블과 변수에 동일한 이름을 사용하면 코드를 읽거나 유지 관리하는 것이 어려워집니다.
n a
PL/SQL 블록의 DECLARE 섹션에서 선언하는 다양한 객체에도 이름 지정 규칙을 적용하는 것이
것을 피할 수 있습니다.
te r
좋습니다. 변수(variable)를 의미하는 v_를 접두어로 붙이면 데이터베이스 객체와 이름이 충돌하는
DECLARE
I n
c l e
v_hire_date date;
a
BEGIN
O r
...
참고: 변수 이름은 30자를 초과해서는 안됩니다. 첫 자는 문자여야 하며 나머지에는 문자, 숫자
또는 특수 기호를 사용할 수 있습니다.

변수 초기화 및 키워드
y 할당 연산자 (:=)
y DEFAULT 키워드
y NOT NULL 제약 조건
구문:
identifier := expr;
예제:
v_hiredate := '01-JAN-2001';
v_ename := 'Maduro';
n l y
e O
변수 초기화 및 키워드
구문 설명:
U s
identifier 스칼라 변수 이름입니다.
A I
expr 변수, 리터럴 또는 함수 호출일 수 있지만 데이터베이스 열일 수는
없습니다. O
변수 값 할당 예제는 다음과 같이 정의됩니다.
l &
a
y V_HIREDATE 식별자를 01-JAN-2001의 값으로 설정합니다.
n
te r
y V_ENAME 식별자에 이름 “Maduro”를 저장합니다.
변수는 블록 또는 서브 프로그램을 시작할 때마다 초기화됩니다. 이때 변수는 기본적으로 NULL로
I n
초기화됩니다. 변수를 명시적으로(explicitly) 초기화하지 않으면 값이 정의되지 않습니다.
l e
대표값이 없는 변수에는 할당 연산자(:=)를 사용합니다.
c
a
v_hire_date := '15-SEP-1999'
O r
참고: YYYY처럼 연도를 네 자리 값으로 할당하는 것은 Oracle8i 이상에서만 가능합니다.
Oracle8i 이전 버전에서는 TO_DATE 함수를 사용해야 합니다.
DEFAULT: 할당 연산자 대신 DEFAULT 키워드를 사용하여 변수를 초기화할 수 있습니다. 대표값이
있는 변수에는 DEFAULT를 사용하십시오.
v_mgr NUMBER(6) DEFAULT 100;

변수 초기화 및 키워드(계속)
NOT NULL: 변수가 반드시 값을 포함해야 하는 경우에는 NOT NULL 제약 조건을 적용합니다.
NOT NULL로 정의된 변수에는 널을 할당할 수 없습니다. NOT NULL 제약 조건 다음에는 초기화
절이 와야 합니다.
v_city VARCHAR2(30) NOT NULL := 'Oxford'
참고: 문자열 리터럴은 작은 따옴표로 묶어야 합니다(예: 'Hello, world'). 문자열에 작은
따옴표가 있는 경우에는 작은 따옴표를 두 번 입력해야 합니다. 예를 들어, FISHERMAN'S
DRIVE와 같은 값을 삽입할 경우 'FISHERMAN''S DRIVE'로 입력합니다.
변수에 값을 할당하는 다른 방법은 데이터베이스 값을 선택하거나 인출(fetch)하는 것입니다.
다음 예제에서는 EMPLOYEE_ID가 176인 직원에 대해 10%의 상여금을 계산하고 계산된 값을
v_bonus 변수에 할당합니다. 이 작업에는 INTO 절을 이용합니다.
DECLARE
v_bonus NUMBER(8,2);
BEGIN
SELECT salary * 0.10
INTO v_bonus
FROM employees
WHERE employee_id = 176;
END;
/
그런 다음 변수 v_bonus를 다른 계산에 사용하거나 해당 값을 데이터베이스 테이블에 삽입할
수 있습니다. n l y
참고: 데이터베이스의 값을 변수에 할당하려면 SELECT 또는 FETCH 문을 사용합니다. FETCH
e O
문은 이 단원의 뒷부분에서 다룹니다.
U s
A I
O
l &
n a
te r
I n
c le
r a
O

스칼라 데이터 유형
• 단일 값을 보유합니다.
• 내부 구성 요소가 없습니다.
25-OCT-99
“87년 전 우리의 선조는 이 대륙에, TRUE
자유 속에서 태어난, 그리고 만민이
평등하게 창조되었다는 신조에 모든
256120.08 것을 바친 새 나라를 건설하였습니다.”
Atlanta
n l y
e O
스칼라 데이터 유형
모든 상수, 변수 및 파라미터는 데이터 유형(또는 유형)을 통해 저장 형식, 제약 조건, 그리고 값의
U s
유효 범위를 지정합니다. PL/SQL은 미리 정의된 다양한 데이터 유형을 제공합니다. 예를 들어
A
정수, 부동 소수점, 문자, 부울, 날짜, collection, 참조, LOB 유형 등에서 선택할 수 있습니다. 이
I
장에서는 PL/SQL 프로그램에서 자주 사용되는 기본 유형을 설명합니다. 이후의 장에서는 더
O
특화된 유형을 다룹니다.
l &
n a
스칼라 데이터 유형은 단일 값을 보유하며 내부 구성 요소가 없습니다. 스칼라 데이터 유형은 숫자,
문자, 날짜, 부울의 네 가지 범주로 분류할 수 있습니다. 문자 및 숫자 데이터 유형은 기본 유형을
및 POSITIVE입니다.
te r
제약 조건과 연결한 서브 유형을 갖습니다. 예를 들어, 기본 유형 NUMBER의 서브 유형은 INTEGER
I n
스칼라 데이터 유형의 전체 목록 및 자세한 내용은 PL/SQL User's Guide and Reference,
le
“Fundamentals”를 참조하십시오.
c
r a
O

기본 스칼라 데이터 유형
y CHAR [(maximum_length)]
y VARCHAR2 (maximum_length)
y LONG
y LONG RAW
y NUMBER [(precision, scale)]
y BINARY_INTEGER
y PLS_INTEGER
y BOOLEAN
n l y
e O
U s
데이터 유형
CHAR
설명
고정 길이 문자 데이터의 기본 유형이며 최대 길이는 A I
O
[(maximum_length)] 32,767바이트입니다. maximum_length를 지정하지 않으면 기본 길이가
1로 설정됩니다.
l &
VARCHAR2
(maximum_length)
n a
가변 길이 문자 데이터의 기본 유형이며 최대 길이는
32,767바이트입니다. VARCHAR2 변수 및 상수는 기본 크기가 없습니다.
LONG
te r
가변 길이 문자 데이터의 기본 유형이며 최대 길이는
I n
32,760바이트입니다. 가변 길이 문자열 저장에는 LONG 데이터 유형을
사용합니다. LONG 열의 최대 폭은 2**31바이트이므로 LONG
c le 데이터베이스 열에는 모든 LONG 값을 삽입할 수 있습니다. 하지만

32,760바이트를 초과하는 값은 LONG 열에서 LONG 변수로 가져올 수
r a 없습니다.
LONG RAW
O 이진 데이터 및 바이트 문자열의 기본 유형이며 최대 길이는
32,760바이트입니다. PL/SQL에서는 LONG RAW 데이터를 해석하지
않습니다.
NUMBER 전체 자릿수 p와 소수점 이하 자릿수 s로 구성된 숫자입니다. 전체
[(precision, scale)] 자릿수 p의 범위는 1부터 38까지입니다. 소수점 이하 자릿수 s의 범위는
-84부터 127까지입니다.

기본 스칼라 데이터 유형(계속)
데이터 유형 설명
BINARY_INTEGER -2,147,483,647과 2,147,483,647 사이에 있는 정수의 기본 유형입니다.
PLS_INTEGER -2,147,483,647과 2,147,483,647 사이에 있는 부호 표시 정수의 기본 유

형입니다. PLS_INTEGER 값은 저장 공간을 적게 사용하고 NUMBER
및 BINARY_INTEGER 값보다 빠릅니다.
BOOLEAN 논리 계산에 사용 가능한 세 가지 값(TRUE, FALSE, NULL) 중 하나를
저장하는 기본 유형입니다.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O

y DATE
y TIMESTAMP
y TIMESTAMP WITH TIME ZONE
y TIMESTAMP WITH LOCAL TIME ZONE
y INTERVAL YEAR TO MONTH
y INTERVAL DAY TO SECOND
n l y
e O
U s
A I
DATE 날짜 및 시간의 기본 유형입니다. DATE는 자정 이후의 시간을 초 단위로
나타내는 값이고 날짜 범위는 B.C 4712년 ~ A.D 9999년입니다. O
TIMESTAMP
l &
DATE 데이터 유형을 확장한 TIMESTAMP 데이터 유형은 연, 월, 일, 시간, 분,
초를 저장합니다. 구문은 다음과 같습니다.
n a
te r
TIMESTAMP[(precision)]
여기서, 선택적 파라미터인 precision은 초 필드의 소수 부분 자릿수를
I n
지정합니다. precision을 지정할 때는 기호 상수나 변수를 사용할 수 없으며,
0부터 9까지 범위의 정수 리터럴을 사용해야 합니다. 기본값은 6입니다.
TIMESTAMP
c l e
TIMESTAMP 데이터 유형을 확장한 TIMESTAMP WITH TIME ZONE 데이터
WITH TIME
ZONE
ra
유형에는 시간대 변위 값이 포함됩니다. 시간대 변위 값은 지역 시간과
UTC(Coordinated Universal Time) 즉, 기존 그리니치 표준시 간의 차이를 시간과
O 분으로 나타낸 것입니다. 구문은 다음과 같습니다.
TIMESTAMP[(precision)] WITH TIME ZONE
지정합니다. precision을 지정할 때는 기호 상수나 변수를 사용할 수 없으며,
0부터 9까지 범위의 정수 리터럴을 사용해야 합니다. 기본값은 6입니다.

TIMESTAMP WITH TIMESTAMP 데이터 유형을 확장한 TIMESTAMP WITH LOCAL TIME
LOCAL TIME ZONE ZONE 데이터 유형에는 시간대 변위 값이 포함됩니다. 시간대 변위
값은 지역 시간과 UTC(Coordinated Universal Time) 즉, 기존 그리니치
표준시 간의 차이를 시간과 분으로 나타낸 것입니다. 구문은 다음과
같습니다.
TIMESTAMP[(precision)] WITH LOCAL TIME ZONE
지정합니다. precision을 지정할 때는 기호 상수나 변수를 사용할 수
없으며, 0부터 9까지 범위의 정수 리터럴을 사용해야 합니다. 기본값은
6입니다.
이 데이터 유형은 데이터베이스 열에 값을 삽입할 때, 값이
데이터베이스의 시간대에 맞게 정규화되고 시간대 변위 값이 열에
저장되지 않는다는 점에서 TIMESTAMP WITH TIME ZONE과
다릅니다. 값을 검색하면 값이 사용자의 지역 세션 시간대에 맞게
반환됩니다.
INTERVAL YEAR 연도와 월의 간격을 저장 및 조작할 때 INTERVAL YEAR TO MONTH
TO MONTH 데이터 유형을 사용합니다. 구문은 다음과 같습니다.
INTERVAL YEAR[(precision)] TO MONTH
여기서, years_precision은 연도 필드의 자릿수를 지정합니다.
전체 자릿수를 지정할 때는 기호 상수나 변수를 사용할 수 없으며,
0부터 4까지 범위의 정수 리터럴을 사용해야 합니다. 기본값은 n l y
2입니다.
e O
INTERVAL DAY TO
SECOND SECOND 데이터 유형을 사용합니다. 구문은 다음과 같습니다.
U s
일, 시간, 분 및 초의 간격을 저장 및 조작할 때 INTERVAL DAY TO
A I
INTERVAL DAY[(precision1)] TO SECOND[(precision2)]
여기서, precision1과 precision2는 각각 일 필드와 초 필드의
O
자릿수를 지정합니다. 두 경우 모두 자릿수를 지정할 때 기호 상수나
변수를 사용할 수 없으며, 0부터 9까지 범위의 정수 리터럴을 사용해야
&
합니다. 기본값은 각각 2와 6입니다.
l
n a
te r
I n
c l e
r a
O

스칼라 변수 선언
예제:
DECLARE
v_job VARCHAR2(9);
v_count BINARY_INTEGER := 0;
v_total_sal NUMBER(9,2) := 0;
v_orderdate DATE := SYSDATE + 7;
c_tax_rate CONSTANT NUMBER(3,2) := 8.25;
v_valid BOOLEAN NOT NULL := TRUE;
...
n l y
e O
스칼라 변수 선언
U s
슬라이드의 변수 선언 예제는 다음과 같이 정의됩니다.
y v_job: 사원 직위를 저장하기 위한 변수입니다.
A I
y v_count: 루프의 반복 횟수를 세기 위한 변수이며 0으로 초기화됩니다.
O
&
y v_total_sal: 부서의 급여 총액을 계산하기 위한 변수이며 0으로 초기화됩니다.
l
초기화됩니다.
n a
y v_orderdate: 주문 출하일을 저장하기 위한 변수이며 오늘부터 일주일 후의 날짜로
te r
y c_tax_rate: 세율에 대한 상수 변수로, PL/SQL 블록에서 절대 변경되지 않습니다.
n
y v_valid: 일부 데이터의 유효성 여부를 나타내는 플래그이며 TRUE로 초기화됩니다.
I
c le
ra
O

%TYPE 속성
y 다음에 따라 변수를 선언합니다.

– 데이터베이스 열 정의
– 이전에 선언한 다른 변수
y %TYPE에 다음을 접두어로 붙입니다.
– 데이터베이스 테이블 및 열
– 이전에 선언한 변수 이름
n l y
e O
%TYPE 속성
열 값을 보유하는 PL/SQL 변수를 선언할 때는 변수의 데이터 유형 및 자릿수가 적절해야 합니다.
U s
그렇지 않으면 실행 중에 PL/SQL 오류가 발생합니다.
변수의 데이터 유형 및 전체 자릿수를 하드 코딩하는 대신 %TYPE 속성을 사용하여 이전에 선언한 A I
변수 또는 데이터베이스 열에 따라 변수를 선언할 수 있습니다. %TYPE 속성은 변수에 저장되는 O
l &
값이 데이터베이스의 테이블에서 파생될 경우에 자주 사용합니다. 변수 선언에 필요한 데이터
유형 대신 이 속성을 사용하려면 속성에 데이터베이스 테이블 및 열 이름을 접두어로 붙입니다.
n
이전에 선언한 변수를 참조하려면 속성에 변수 이름을 접두어로 붙입니다.a
te r
PL/SQL은 블록을 컴파일할 때 변수의 데이터 유형 및 크기를 결정하므로 변수 값을 채울 때
사용되는 열과 변수는 항상 호환됩니다. 따라서 데이터베이스 레벨에서의 열 데이터 유형 변경에
I n
주의하지 않아도 되므로 코드 작성 및 유지 관리에 큰 도움이 됩니다. 속성에 변수 이름을 접두어로
c le
붙여 이전에 선언한 다른 변수에 따라 변수를 선언할 수도 있습니다.
ra
O

%TYPE 속성을 사용하여 변수 선언
구문:
identifier Table.column_name%TYPE;
예제:
...
v_name employees.last_name%TYPE;
v_balance NUMBER(7,2);
v_min_balance v_balance%TYPE := 10;
...
n l y
e O
%TYPE 속성을 사용하여 변수 선언
직원의 성을 저장하기 위한 변수를 선언합니다. v_name 변수는 EMPLOYEES 테이블의
U s
LAST_NAME 열과 동일한 데이터 유형으로 정의됩니다. %TYPE은 데이터베이스 열과 같은 데이터
유형을 제공합니다. A I
...
O
v_name
...
employees.last_name%TYPE;
l &
a
은행 계좌의 잔액과, 10부터 시작하는 최소 잔액을 저장하기 위한 변수를 선언합니다.
n
지정된 변수와 같은 데이터 유형을 제공합니다.
te r
v_min_balance 변수는 v_balance 변수와 동일한 데이터 유형으로 정의됩니다. %TYPE은
...
v_balance
I n NUMBER(7,2);
...
c l
v_min_balance
e v_balance%TYPE := 10;
ra
%TYPE을 사용하여 선언한 변수에는 NOT NULL 데이터베이스 열 제약 조건을 적용할 수 없습니다.
O
따라서 NOT NULL로 정의된 데이터베이스 열을 사용하는 %TYPE 속성을 사용해서 선언한
변수에는 NULL 값을 할당할 수 있습니다.

부울 변수 선언
y 부울 변수에는 TRUE, FALSE 및 NULL 값만 할당할 수

있습니다.
y 변수 비교에는 논리 연산자 AND, OR 및 NOT을
사용합니다.
y 변수의 결과는 항상 TRUE, FALSE 또는 NULL입니다.
y 부울 값을 반환할 때 산술, 문자 및 날짜 표현식을
사용할 수 있습니다.
n l y
e O
부울 변수 선언
PL/SQL을 사용하면 SQL 문 및 프로시저문에서 변수를 비교할 수 있습니다. 이러한 비교를 부울
U s
표현식이라고 하는데, 부울 표현식은 관계형 연산자로 구분되는 단순 또는 복합 표현식으로
구성됩니다. SQL 문에서 부울 표현식을 사용하여 명령문의 영향을 받는 테이블의 행(row)을 A I
지정할 수 있습니다. 프로시저문에서 부울 표현식은 조건 제어의 기본 사항입니다. NULL은 누락,
O
부적절 또는 알 수 없는 값을 나타냅니다.
예제
l &
v_sal1 := 50000;
n a
v_sal2 := 60000;
다음 표현식의 결과는 TRUE입니다.
te r
I
v_sal1 < v_sal2 n
c l e
DECLARE
ra
부울 변수를 선언하고 초기화합니다.
BEGIN O
v_flag BOOLEAN := FALSE;
v_flag := TRUE;
END;

조합 데이터 유형
TRUE 23-DEC-98 ATLANTA
PL/SQL 테이블 구조 PL/SQL 테이블 구조
1 SMITH 1 5000
2 JONES 2 2345
3 NANCY 3 12
4 TIM 4 3456
VARCHAR2 NUMBER
y
BINARY_INTEGER BINARY_INTEGER
n l
e O
스칼라 유형에는 내부 구성 요소가 없습니다. 조합 유형에는 개별적으로 조작할 수 있는 내부 구성
U s
VARRAY 유형이 있습니다. 서로 관련이 있지만 유사하지 않은 데이터를 논리적 단위로 다룰 때에는
A I
요소가 있습니다. 조합 데이터 유형(collection이라고도 함)에는 TABLE, RECORD, NESTED TABLE,
RECORD 데이터 유형을 사용합니다. RECORD와 TABLE 데이터 유형은 뒷 단원에서 자세히
O
l &
다룹니다. NESTED TABLE과 VARRAY 데이터 유형은 Advanced PL/SQL 과정에서 다룹니다.
자세한 내용은 PL/SQL User's Guide and Reference, “Collections and Records”를 참조하십시오.
n a
te r
I n
c l e
ra
O

LOB 데이터 유형 변수
책
(CLOB)
사진
(BLOB)
영화
(BFILE)
NCLOB
n l y
e O
LOB 데이터 유형 변수
LOB (Large OBject - 대형 객체) 데이터 유형을 사용하면 구조화되지 않은 데이터 블록(예: 텍스트,
U s
그래픽 이미지, 비디오 클립, 사운드 웨이브 폼 등)을 4GB까지 저장할 수 있습니다. LOB 데이터
유형은 데이터에 대한 효율적, 임의적, 불연속적 액세스를 가능하게 하며 객체 유형의 속성이 될 A I
수도 있습니다. LOB을 사용하면 데이터를 임의로 액세스할 수도 있습니다.
O
l &
y CLOB (Character Large OBject - 문자 대형 객체) 데이터 유형은 단일 바이트 문자 데이터의
대형 블록을 데이터베이스에 순서대로(행 내부) 또는 순서 없이(행 외부)로 저장하는 데
사용됩니다.
n a
te r
y BLOB (Binary Large OBject - 이진 대형 객체) 데이터 유형은 대형 이진 객체를
데이터베이스에 순서대로(행 내부) 또는 순서 없이(행 외부) 저장하는 데 사용합니다.
I n
y BFILE (Binary FILE - 이진 파일) 데이터 유형은 대형 이진 객체를 데이터베이스 외부에 있는
c l e
운영 체제 파일에 저장합니다.
y NCLOB (National language Character Large OBject - 국가별 언어 문자 대형 객체) 데이터 유형은
ra
단일 바이트 또는 고정 폭 멀티 바이트 NCHAR 유니코드 데이터를 데이터베이스에 순서대로
또는 순서 없이 저장하는 데 사용합니다.
O

바인드 변수
O/S
바인드 변수
서버
n l y
e O
바인드 변수
바인드 변수는 호스트 환경에서 선언한 변수입니다. 바인드 변수는 런타임 값(숫자 또는 문자)을
U s
하나 이상의 PL/SQL 프로그램과 주고 받는 데 사용합니다. PL/SQL 프로그램은 바인드 변수를
다른 변수와 같은 방식으로 사용합니다. 명령문이 프로시저, 함수 또는 패키지에 있는 경우를 A I
제외하고는 호스트 또는 호출 환경에서 선언한 변수를 PL/SQL 문에서 참조할 수 있습니다.
O
프로그램의 화면 필드 및 iSQL*Plus 바인드 변수가 포함됩니다.
l &
여기에는 선행 컴파일러 프로그램에서 선언한 호스트 언어 변수, Oracle Developer Forms 응용
바인드 변수 생성
n a
te r
iSQL*Plus 환경에서 바인드 변수를 선언하려면 VARIABLE 명령을 사용합니다. 예를 들어, 다음과
같이 NUMBER 및 VARCHAR2 유형의 변수를 선언합니다.
I n
VARIABLE return_code NUMBER
c le
VARIABLE return_msg VARCHAR2(30)
SQL과 iSQL*Plus 모두 바인드 변수를 참조할 수 있으며, iSQL*Plus에서는 iSQL*Plus PRINT
ra
명령을 통해 그 값을 표시할 수 있습니다.

바인드 변수 표시
iSQL*Plus 환경에서는 PRINT 명령을 사용하여 바인드 변수의 현재 값을 표시할 수 있습니다.
하지만 PRINT는 iSQL*Plus 명령이기 때문에 PL/SQL 블록 내에서 사용할 수 없습니다. 다음
예제는 PRINT 명령을 보여줍니다.
VARIABLE g_n NUMBER
...
PRINT g_n
PL/SQL 프로그램에서 호스트 변수를 참조할 수 있습니다. 이 변수에는 콜론(:)을 접두어로
붙여야 합니다.
VARIABLE RESULT NUMBER
PL/SQL 블록에서의 호스트 변수 사용 예제:

BEGIN
SELECT (SALARY*12) + NVL(COMMISSION_PCT,0) INTO :RESULT
FROM employees WHERE employee_id = 144;
END;
/
PRINT RESULT
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O

바인드 변수 사용
PL/SQL에서 바인드 변수를 참조하려면 이름에 콜론(:)을

접두어로 붙여야 합니다.
예제:
VARIABLE g_salary NUMBER
BEGIN
SELECT salary
INTO :g_salary
FROM employees
END;
/
PRINT g_salary
n l y
e O
바인드 변수 출력
iSQL*Plus에서는 PRINT 명령을 사용하여 바인드 변수의 값을 표시할 수 있습니다.
U s
A I
O
l &
n a
te r
I n
c le
ra
O

비 PL/SQL 변수 참조
연봉을 iSQL*Plus 호스트 변수에 저장합니다.
:g_monthly_sal := v_sal / 12;
• 비 PL/SQL 변수를 호스트 변수로 참조합니다.

• 참조 대상에 콜론(:)을 접두어로 붙입니다.
n l y
e O
비 PL/SQL 변수 참조
호스트 변수를 참조하려면 참조 대상에 콜론(:)을 접두어로 붙여 선언된 PL/SQL 변수와 구분해야
U s
합니다.
A I
예제
다음은 사용자가 제공한 연봉을 기준으로 월급을 계산하는 예제입니다. 이 스크립트에는 전체 O
PL/SQL 블록과 iSQL*Plus 명령이 모두 들어 있습니다.
l &
VARIABLE
n
g_monthly_sal NUMBER a
DEFINE
te r
p_annual_sal = 50000
I
SET VERIFY OFF
DECLARE n
BEGIN l e
v_sal NUMBER(9,2) := &p_annual_sal;
c
r a:g_monthly_sal := v_sal/12;
O
END;
/
PRINT g_monthly_sal
DEFINE 명령은 사용자 변수를 지정하고 그 변수에 CHAR 값을 할당합니다. 사용자가 숫자 50000을
입력하더라도 iSQL*Plus에서는 문자 5,0,0,0,0으로 구성된 CHAR 값이 p_annual_sal에
할당됩니다.

DBMS_OUTPUT.PUT_LINE
y 오라클 지원 패키지 프로시저입니다.
y PL/SQL 블록에서 데이터를 표시하는 또 하나의
방법입니다.
y SET SERVEROUTPUT ON을 사용하여 iSQL*Plus에서
사용 가능하도록 설정합니다.
SET SERVEROUTPUT ON
DEFINE p_annual_sal = 60000
DECLARE
v_sal NUMBER(9,2) := &p_annual_sal;
BEGIN
v_sal := v_sal/12;
DBMS_OUTPUT.PUT_LINE ('The monthly salary is ' ||
TO_CHAR(v_sal));
END;
/
n l y
e O
앞에서는 호스트 변수를 선언하여 PL/SQL 블록에서 호스트 변수를 참조한 후 PRINT 명령을
U s
사용하여 해당 내용을 iSQL*Plus에 표시하는 방법을 배웠습니다. PL/SQL 블록에서 정보를
표시하는 다른 방법은 DBMS_OUTPUT.PUT_LINE입니다. 여기에서 DBMS_OUTPUT은 오라클 지원
A I
패키지이고 PUT_LINE은 이 패키지에 포함된 프로시저입니다.
O
l &
PL/SQL 블록 내에서 DBMS_OUTPUT.PUT_LINE을 참조하고 화면에 출력하고자 하는 문자열을
괄호로 묶어 지정합니다. 이때 먼저 iSQL*Plus 세션에서 패키지를 사용 가능하도록 설정해야
a
합니다. 이렇게 하려면 SET SERVEROUTPUT ON이라는 iSQL*Plus 명령을 실행하면 됩니다.
n
표시하는 것입니다. 출력 결과는 다음과 같습니다.
te r
슬라이드의 예제는 월급을 계산해서 DBMS_OUTPUT.PUT_LINE을 이용하여 그 결과를 화면에
I n
c le
r a
O

요약
이 단원에서는 다음과 같은 내용을 배웠습니다.

y PL/SQL 블록은 다음 부분으로 구성됩니다.
– 선언 부분(선택사항)
– 실행 부분(필수사항)
– 예외 처리 부분(선택사항)
y PL/SQL 블록은 익명 블록, 프로시저 또는 …
DECLARE
함수일 수 있습니다.
…
BEGIN
…
EXCEPTION
END;
n l y
e O
요약
PL/SQL 블록은 PL/SQL 프로그램의 이름이 지정되지 않은 기본 단위입니다. PL/SQL 블록은 SQL
U s
또는 PL/SQL 문으로 구성되며 단일한 논리적 기능을 수행합니다. 선언 부분은 PL/SQL 블록의
첫번째 부분이며 변수, 상수, 커서, 오류 상황(예외 사항) 정의 등의 객체 선언에 사용합니다. 실행 A I
O
부분은 PL/SQL 블록의 필수 부분으로서 데이터 질의 및 조작에 필요한 SQL 및 PL/SQL 문을
l &
포함합니다. 예외 처리 부분은 블록의 실행 부분에 포함되며 실행 부분의 맨 끝에 위치합니다.
익명 PL/SQL 블록은 PL/SQL 프로그램의 이름이 지정되지 않은 기본 단위입니다. 프로시저 및
n a
함수는 필요할 때마다 곧바로 실행할 수 있도록 오라클 데이터베이스에서 개별적으로 컴파일하여
영구적으로 저장해둘 수 있습니다.
te r
I n
c le
ra
O

요약
y PL/SQL 식별자:
– 선언 부분에 정의합니다.
– 스칼라, 조합, 참조 또는 LOB 데이터 유형일 수 있습니다.
– 다른 변수 또는 데이터베이스 객체의 구조를 기반으로 할
수 있습니다.
– 초기화할 수 있습니다.
y iSQL*Plus와 같은 외부 환경에서 선언된 변수를 호스트
변수라고 합니다.
y PL/SQL 블록에서 데이터를 표시하려면
DBMS_OUTPUT.PUT_LINE을 사용합니다.
n l y
e O
요약(계속)
모든 PL/SQL 데이터 유형은 스칼라, 조합, 참조 또는 LOB 유형입니다. 스칼라 데이터 유형에는
U s
구성 요소가 없는 반면, 조합 데이터 유형은 다른 데이터 유형을 포함합니다. PL/SQL 변수는 선언
부분에서 선언 및 초기화됩니다. A I
O
iSQL*Plus를 사용하여 PL/SQL 프로그램을 작성 및 실행하면, iSQL*Plus가 PL/SQL 프로그램의
l &
호스트 환경이 됩니다. iSQL*Plus에서 선언한 변수를 호스트 변수라고 합니다. 이와 마찬가지로
Oracle Forms 등을 이용하여 PL/SQL 프로그램을 작성 및 실행하면 Forms가 호스트 환경이 되며
a
Oracle Forms에서 선언한 변수를 호스트 변수라고 합니다. 호스트 변수는 바인드 변수라고도
n
합니다.
te r
PL/SQL 블록에서 정보를 표시하려면 DBMS_OUTPUT.PUT_LINE을 사용합니다. DBMS_OUTPUT은
I n
오라클 지원 패키지이며, PUT_LINE은 이 패키지 내의 프로시저입니다. PL/SQL 블록 내에서
DBMS_OUTPUT.PUT_LINE을 참조하고 화면에 출력하고자 하는 문자열을 괄호로 묶어
지정합니다.
c le
ra
O

연습 1 개요
이 연습에서는 다음 내용을 다룹니다.

y 선언의 유효성 판별
y 간단한 PL/SQL 블록 선언
y 간단한 PL/SQL 블록 실행
n l y
e O
연습 1 개요
이 연습을 통해 이 단원에서 배운 데이터 유형, 식별자 정의, 표현식 검증 등의 PL/SQL 기본 사항을
U s
보충할 수 있습니다. 여기서 배운 모든 요소를 사용하여 간단한 PL/SQL 블록을 작성해 보십시오.
A I
문제
문제 1과 2는 실습이 필요 없는 간단한 문제입니다. O
l &
n a
te r
I n
c le
ra
O

연습 1
1. 다음에 있는 각 선언을 평가하고 잘못된 것을 찾아 이유를 설명하십시오.
a. DECLARE
v_id NUMBER(4);
b. DECLARE
v_x, v_y, v_z VARCHAR2(10);
c. DECLARE
v_birthdate DATE NOT NULL;
d. DECLARE
v_in_stock BOOLEAN := 1;
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O

연습 1(계속)
2. 다음의 할당문이 모두 적합한지, 결과로 적합한 데이터 유형은 무엇인지 답하십시오.
a. v_days_to_go := v_due_date - SYSDATE;
b. v_sender := USER || ': ' || TO_CHAR(v_dept_no);
c. v_sum := $100,000 + $250,000;
d. v_flag := TRUE;
e. v_n1 := v_n2 > (2 * v_n3);
f. v_value := NULL;
n l y
e O
s
3. “My PL/SQL Block Works”라는 구문을 화면에 출력하는 익명 블록을 작성하십시오.
U
A I
O
l &
n a
te r
I n
c l e
r a
O

연습 1(계속)
시간이 있을 때 다음 문제를 풀어보십시오.
4. 두 변수를 선언하는 블록을 작성한 다음 이러한 PL/SQL 변수의 값을 iSQL*Plus 호스트
변수에 할당하고 PL/SQL 변수의 결과를 화면에 출력하십시오. PL/SQL 블록을
실행하십시오. 그런 다음 Save Script 버튼을 클릭하여 PL/SQL 블록을
p16q4.sql이라는 파일로 저장하십시오. 스크립트는 .sql 확장자로 저장합니다.
V_CHAR Character (variable length)

V_NUM Number
다음과 같이 변수에 값을 할당하십시오.
Variable Value
-------- -------------------------------------
V_CHAR The literal '42 is the answer'
V_NUM The first two characters from V_CHAR
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O

실행문 작성
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 실행 부분의 중요성 설명
y 식별자의 올바른 사용
y 실행 부분에서 명령문 작성
y 중첩 블록의 규칙 설명
y PL/SQL 블록 실행 및 테스트
y 코딩 규칙 사용
n l y
e O
단원 목표
U s
이 단원에서는 PL/SQL 블록에 실행 가능한 코드를 작성하는 방법을 설명합니다. 또한 PL/SQL
코드의 실행 및 테스트 방법과 PL/SQL 코드 블록의 중첩 규칙을 설명합니다.
A I
O
l &
n a
te r
I n
c le
ra
O

PL/SQL 블록 구문 및 지침
y 명령문은 여러 행에 나누어 쓸 수 있습니다.

y 렉시칼 단위는 다음과 같이 분류할 수 있습니다.
− 구분자
− 식별자
− 리터럴
− 주석
n l y
e O
U s
PL/SQL은 SQL의 기능을 확장한 것이므로 SQL에 적용되는 일반 구문 규칙은 PL/SQL 언어에도
적용됩니다.
A I
O
y PL/SQL 텍스트 행에 포함되는 문자 그룹을 렉시칼 단위라고 하며 다음과 같이 분류할 수
있습니다.
− 구분자(단순 및 혼합 기호)
l &
− 예약어가 포함된 식별자
n a
−
−
리터럴
주석
te r
I n
y 렉시칼 단위 사이에는 읽기 쉽도록 공백을 둘 수 있습니다. 사실, 인접한 식별자는
le
공백이나 구두점으로 분리해야 합니다.
c
y 문자열 리터럴과 주석을 제외한 렉시칼 단위에는 공백이 포함될 수 없습니다.
r a
y 명령문은 여러 행에 나누어 쓸 수 있지만 키워드는 나누어 쓸 수 없습니다.

PL/SQL 블록 구문 및 지침(계속)
구분자
구분자는 PL/SQL에서 특별한 의미를 가지는 단순 기호나 혼합 기호입니다.
단순 기호
기호 의미
+ 더하기 연산자
- 빼기/부정 연산자
* 곱하기 연산자
/ 나누기 연산자
= 관계 연산자
@ 원격 액세스 표시자
; 명령문 종료자
혼합 기호
기호
<>
의미
관계 연산자 n l y
!= 관계 연산자
e O
|| 연결 연산자
U s
--
/*
단일 행 주석 표시자
주석 시작 구분자
A I
*/ 주석 종료 구분자 O
:= 할당큰
참고: 예약어는 연산자
l &
따옴표로 묶어야 식별자로 사용할 수 있습니다(예: “SELECT”).
n a
te r
I n
c le
r a
O

식별자
y 최대 30자까지 지정할 수 있습니다.

y 영문자로 시작해야 합니다.
y 숫자, 달러 기호, 밑줄 및 번호 기호(#)를 포함할 수
있습니다.
y 하이픈(-), 슬래시(/) 및 공백과 같은 문자는 포함할 수
없습니다.
y 데이터베이스 테이블 열 이름과 동일하면 안됩니다.
y 예약어가 아니어야 합니다.
n l y
e O
식별자
U s
식별자는 상수, 변수, 예외 사항, 커서, 커서 변수, 서브 프로그램 및 패키지를 비롯한 PL/SQL
프로그램 항목 및 단위의 이름을 지정하는 데 사용됩니다.
A I
y 식별자는 30자까지 가능하고 영문자로 시작해야 합니다.
O
l &
y 블록에 사용되는 테이블의 열 이름과 식별자 이름이 동일하면 안됩니다. PL/SQL 식별자가
동일한 SQL 문에 있으며 식별자 이름이 열 이름과 동일하면 오라클은 PL/SQL 식별자를
참조되는 열로 간주합니다.
n a
te r
y 예약어는 읽기 쉽도록 대문자로 작성해야 합니다.
y 식별자는 문자로 시작해야 하고, 그 뒤에 선택적으로 다른 문자, 숫자, 달러 기호, 밑줄 및
I n
번호 기호(#)를 사용할 수 있습니다. 다음 예의 하이픈(-), 슬래시(/) 및 공백은 허용되지
않습니다.
cl e
dots&dashes -- 잘못된 앰퍼샌드
r a
debit-amount
on/off
--
--
잘못된 하이픈
잘못된 슬래시
Ouser id -- 잘못된 공백
money$$$tree, SN##, try_again_ 등과 같이, 달러 기호, 밑줄 및 번호 기호(#)가 연결
문자로 사용되거나 뒤에 오는 것은 허용됩니다.

y 리터럴
− 문자 및 날짜 리터럴은 작은 따옴표로 묶어야 합니다.
v_name := 'Henderson';
− 숫자로는 단순 값이나 과학적 표기법을 사용할 수

있습니다.
y 슬래시(/)는 스크립트 파일 또는 iSQL*PLUS와 같은
일부 툴에서 PL/SQL 블록을 실행합니다.
n l y
e O
U s
리터럴은 식별자로 표현되지 않는 명시적(explicit) 숫자, 문자, 문자열 또는 부울 값입니다.
y 문자 리터럴에는 문자, 숫자, 공백, 특수 기호 등과 같은 PL/SQL 문자 집합에 있는 출력
A I
가능한 모든 문자가 포함됩니다.
O
의미하는 2E5)을 사용할 수 있습니다.
l &
y 숫자 리터럴에는 단순 값(예: -32.5)이나 과학적 표기법(예: 2* (10의 5승), 즉 200000을
a
행에 슬래시( / )만 있으면 PL/SQL 프로그램이 종료 및 실행됩니다.
n
te r
I n
c le
r a
O

코드에 주석 달기
y 단일 행 주석에는 대시 두 개(--)를 접두어로 붙입니다.

y 여러 행 주석은 기호 /*와 */ 사이에 작성합니다.
예제:
DECLARE
...
v_sal NUMBER (9,2);
BEGIN
/* Compute the annual salary based on the
monthly salary input from the user */
v_sal := :g_monthly_sal * 12;
END; -- This is the end of the block
n l y
e O
코드에 주석 달기
U s
코드에 주석을 달면 각 단계에 대한 설명을 기록할 수 있고 디버깅에 도움이 됩니다. 주석이
단일 행인 경우 대시 두 개(--)를 사용하여 PL/SQL 코드에 주석을 달고, 주석이 여러 행에 걸쳐
있는 경우 기호 /*와 */ 사이에 작성합니다. 주석은 단지 내용을 설명하기 위한 것이며 동작 A I
논리 또는 데이터의 조건이나 동작에는 아무 영향도 미치지 않습니다. 주석을 잘 배치하면 코드 O
읽기가 쉬워지며 향후 코드의 유지 관리에도 매우 유용합니다.
l &
예제
n a
r
슬라이드의 예제에서 /*와 */로 묶인 행은 다음에 오는 코드를 설명하는 주석입니다.
te
I n
c le
ra
O

PL/SQL의 SQL 함수
y 다음은 프로시저문에서 사용할 수 있습니다.

− 단일 행(row) 숫자
}
− 단일 행(row) 문자
− 데이터 유형 변환
SQL의 함수와 동일함
− 날짜
− 시간 기록
– GREATEST 및 LEAST
− 기타 함수
y 다음은 프로시저문에서 사용할 수 없습니다.
– DECODE
− 그룹 함수
n l y
e O
PL/SQL의 SQL 함수
U s
SQL에서 사용 가능한 대부분의 함수는 PL/SQL 표현식에서도 사용할 수 있습니다.
y 단일 행(row) 숫자 함수
A I
y 단일 행(row) 문자 함수
O
y 데이터 유형 변환 함수
l &
y 날짜 함수
n a
y 시간 기록 함수
y GREATEST, LEAST
te r
y 기타 함수
I n
c
y DECODE l e
다음 함수는 프로시저문에서 사용할 수 없습니다.
r a
y 그룹 함수: AVG, MIN, MAX, COUNT, SUM, STDDEV 및 VARIANCE입니다. 그룹 함수는
O 테이블의 행 그룹에 적용되므로 PL/SQL 블록 내의 SQL 문에서만 사용할 수 있습니다.

PL/SQL의 SQL 함수: 예제
y 회사의 메일 수신 그룹 목록을 작성합니다.

v_mailing_address := v_name||CHR(10)||
v_address||CHR(10)||v_state||
CHR(10)||v_zip;
y 사원 이름을 소문자로 변환합니다.

v_ename := LOWER(v_ename);
n l y
e O
PL/SQL의 SQL 함수: 예제
U s
PL/SQL에서는 SQL 함수 대부분을 사용할 수 있습니다. 이런 내장 함수는 데이터 조작에 도움이
되며 다음과 같은 범주로 분류할 수 있습니다.
A I
y 숫자
y 문자 O
y 변환
l &
y 날짜
n a
y 기타
슬라이드의 함수 예제는 다음과 같이 정의됩니다.
te r
I n
y 회사의 메일 수신 그룹 주소를 작성합니다.
le
y 이름을 소문자로 변환합니다.
c
r a
CHR는 ASCII 코드를 해당 문자로 변환하는 SQL 함수입니다. 10은 줄바꿈 코드입니다.
PL/SQL에는 다음과 같은 자체 오류 처리 함수가 있습니다.
O
y SQLCODE
y SQLERRM (이 오류 처리 함수는 이 과정 뒷부분에서 설명합니다.)

데이터 유형 변환
y 데이터를 비교 가능한 데이터 유형으로 변환합니다.

y 데이터 유형을 혼합 사용하면 오류가 발생하고 성능에
영향을 미칩니다.
y 변환 함수
– TO_CHAR
– TO_DATE
– TO_NUMBER
DECLARE
v_date DATE := TO_DATE('12-JAN-2001', 'DD-MON-YYYY');
BEGIN
. . .
n l y
e O
U s
PL/SQL은 명령문에서 데이터 유형이 혼합 사용될 경우 동적으로 변환을 시도합니다. 예를 들어
CHAR 변수에 NUMBER 값을 할당하면, PL/SQL은 동적으로 숫자를 CHAR 변수에 저장할 수 있는
A I
문자 표현으로 변환합니다. 또한 문자 표현식이 숫자 값을 나타내는 경우에는 반대로
적용됩니다. O
l &
호환 가능한 유형인 경우 문자를 DATE 변수에 할당할 수 있으며 반대의 경우도 가능합니다.
a
표현식에서는 동일한 데이터 유형을 사용해야 합니다. 표현식에 데이터 유형이 혼합 사용되는
n
구문
te r
경우 적합한 변환 함수를 사용하여 데이터를 변환해야 합니다.
TO_CHAR (value, fmt)

I n
TO_DATE (value, fmt)
c l e
TO_NUMBER (value, fmt)
설명:
r a value 문자열, 숫자 또는 날짜입니다.
O fmt 값을 변환하는 데 사용되는 형식 모델입니다.

변수 v_date를 DATE 데이터 유형으로 선언하면

컴파일 오류가 발생합니다.
v_date := 'January 13, 2001';
n l y
e O
데이터 유형 변환(계속)
U s
슬라이드의 변환 예제는 다음과 같이 정의됩니다.
날짜를 나타내는 문자열을 DATE 데이터 유형으로 선언된 변수에 저장합니다. 이 코드에서는
A I
구문 오류가 발생합니다.
O
l &
n a
te r
I n
c le
ra
O

TO_DATE 변환 함수를 사용하여 오류를 수정합니다.
v_date := TO_DATE ('January 13, 2001',

'Month DD, YYYY');
n l y
e O
데이터 유형 변환(계속)
U s
슬라이드의 변환 예제는 이전 슬라이드의 오류를 수정한 것으로 다음과 같이 정의됩니다.
변환 함수 TO_DATE로 문자열을 날짜로 변환하여 이전 슬라이드의 오류를 수정합니다.
A I
변환이 가능하다면 PL/SQL에서 자체적으로 변환을 시도하지만 성공 여부는 수행되는 작업에
O
l &
따라 다릅니다. 따라서, 데이터 유형을 명시적으로(explicitly) 변환하면 성능이 향상되고
소프트웨어 버전이 변경되어도 사용할 수 있으므로 이렇게 하는 것이 좋은 프로그래밍
습관입니다.
n a
te r
I n
c le
ra
O

중첩 블록 및 변수 범위
y PL/SQL 블록은 실행문을 사용 가능한 모든 곳에서

중첩할 수 있습니다.
y 중첩 블록은 하나의 명령문이 됩니다.
y EXCEPTION 섹션은 중첩 블록을 포함할 수 있습니다.
y 식별자의 범위는 식별자를 참조할 수 있는 프로그램
단위(블록, 서브 프로그램, 패키지)의 영역입니다.
n l y
e O
중첩 블록
U s
SQL과 비교할 때 PL/SQL의 장점 중 하나는 명령문을 중첩할 수 있다는 점입니다. 실행문이
사용 가능한 모든 곳에서 블록을 중첩할 수 있으므로 중첩 블록은 하나의 명령문이 될 수 있으며
A I
블록의 실행 부분을 더 작은 블록으로 나눌 수 있습니다. EXCEPTION 섹션 또한 중첩 블록을
포함할 수 있습니다. O
변수 범위
l &
n a
식별자에 대한 참조는 식별자의 범위와 가시성에 따라 처리됩니다. 식별자의 범위는 식별자를
te r
참조할 수 있는 프로그램 단위(블록, 서브 프로그램 또는 패키지)의 영역에 해당됩니다.
식별자는 검증되지 않은 이름(unqualified name)을 사용하여 식별자를 참조할 수 있는
I n
영역에서만 볼 수 있습니다. PL/SQL 블록에서 선언된 식별자는 해당 블록에 대해서는 지역
식별자로, 그 블록의 모든 서브 블록에 대해서는 전역 식별자로 간주됩니다. 하지만 전역
le
식별자를 참조하려면 검증된 이름(qualified name)을 사용해야 하므로 서브 블록 내에서는 지역
c
식별자만 볼 수 있습니다.
ra
같은 블록에서 식별자를 두 번 선언할 수 없지만 같은 식별자를 두 개의 블록에서 선언하는 것은
O
가능합니다. 식별자가 나타내는 두 항목은 구분되며 한 개가 수정되더라도 다른 것에는 영향을
미치지 않습니다. 그러나 블록은 동일한 레벨의 다른 블록에서 선언된 식별자를 참조할 수
없습니다. 그런 식별자는 해당 블록에 대해 지역도 아니고 전역도 아니기 때문입니다.

예제:
...
x BINARY_INTEGER;
BEGIN
... x의 범위
DECLARE
y NUMBER;
BEGIN y의 범위
y:= x;
END;
...
END;
n l y
e O
U s
슬라이드의 중첩 블록에 있는 변수 y는 변수 x를 참조할 수 있지만, 변수 x는 y의 범위 밖에서
변수 y를 참조할 수 없습니다. 중첩 블록에 있는 변수 y에 외부 블록에 있는 변수 x와 동일한
A I
이름을 지정하면 그 값은 중첩 블록 내에서만 유효합니다.
범위 O
l &
식별자의 범위는 식별자를 참조할 수 있는 프로그램 단위(블록, 서브 프로그램, 패키지)의
영역입니다.
n a
가시성
te r
식별자는 검증되지 않은 이름(unqualified name)을 사용하여 식별자를 참조할 수 있는
영역에서만 볼 수 있습니다.
I n
c le
ra
O

식별자 범위
식별자는 식별자를 수식 없이 참조할 수 있는 영역에서 볼

수 있습니다.
y 블록은 상위 블록을 조회할 수 있습니다.
y 블록은 서브 블록을 조회할 수 없습니다.
n l y
e O
식별자 범위
U s
식별자는 식별자가 선언된 블록과 모든 중첩 서브 블록, 프로시저 및 함수에서 볼 수 있습니다.
블록이 지역 식별자를 찾지 못하면 상위(부모) 블록의 선언 부분을 검색합니다. 블록은 서브
(자식) 블록 및 인접한 형제 블록을 검색하지 않습니다. A I
범위는 변수, 커서, 사용자가 정의한 예외 사항, 상수를 포함하여 선언된 모든 객체에 O
적용됩니다.
l &
n a
te r
I n
c le
ra
O

식별자의 명확한 지정
y 수식자는 상위 블록의 레이블이 될 수 있습니다.

y 블록 레이블 접두어를 사용하여 식별자를 명확하게
지정합니다.
<<outer>>
DECLARE
birthdate DATE;
BEGIN
DECLARE
birthdate DATE;
BEGIN
...
outer.birthdate :=
TO_DATE('03-AUG-1976',
'DD-MON-YYYY');
END;
....
END;
n l y
e O
식별자의 명확한 지정
U s
블록 레이블 접두어를 사용하여 식별자를 수식합니다. 슬라이드의 예제에서 외부 블록에는
outer라는 레이블이 지정되었습니다. 내부 블록에는 외부 블록의 변수와 이름이 같은
birthdate 변수가 선언되었습니다. 이 경우 내부 블록에서 외부 블록에 있는 birthdate A I
변수를 참조하려면 outer.birthdate처럼 변수에 블록 이름을 접두어로 붙입니다. O
l &
블록 레이블에 대한 자세한 내용은 PL/SQL User's Guide and Reference, “Fundamentals”를
참조하십시오.
n a
te r
I n
c l e
ra
O

변수 범위의 확인
클래스 연습 문제
<<outer>>
DECLARE
v_sal NUMBER(7,2) := 60000;
v_comm NUMBER(7,2) := v_sal * 0.20;
v_message VARCHAR2(255) := ' eligible for commission';
BEGIN
DECLARE
v_sal NUMBER(7,2) := 50000;
v_comm NUMBER(7,2) := 0;
v_total_comp NUMBER(7,2) := v_sal + v_comm;
BEGIN
v_message := 'CLERK not'||v_message;
outer.v_comm := v_sal * 0.30;
1
END;
v_message := 'SALESMAN'||v_message;
2
y
END;
n l
e O
클래스 연습 문제
U s
슬라이드의 PL/SQL 블록을 평가하고 범위 지정 규칙에 따라 다음 값을 각각 검토하십시오.
1. 1번 위치에서 V_MESSAGE의 값
A I
2. 2번 위치에서 V_TOTAL_COMP의 값
O
3. 1번 위치에서 V_COMM의 값
4. 1번 위치에서 outer. V_COMM의 값
l &
5. 2번 위치에서 V_COMM의 값
n a
6. 2번 위치에서 V_MESSAGE의 값
te r
I n
c l e
r a
O

PL/SQL의 연산자
y 논리
y 산술 SQL의 연산자와
y 연결 동일함
y 연산 순서를 제어하는 괄호
y 지수 연산자 (**)
n l y
e O
연산 순서
U s
표현식에 있는 연산은 우선순위에 따라 순서대로 처리됩니다. 다음 표는 연산의 기본 순서를
우선순위가 높은 것부터 낮은 것의 순서로 정리한 것입니다.
A I
연산자 연산 O
**
l& 지수화
na
+, - 항등식, 부정
*, /
+, -, ||
t e r 곱하기, 나누기
더하기, 빼기, 연결
I n
=, <, >, <=, >=, <>, !=, ~=, ^=, 비교
NOT
c e
IS NULL, LIKE, BETWEEN, IN
l 논리적 부정
AND
r a 논리곱
OR
O 논리합
참고: 부울 표현식에서 괄호를 사용할 필요는 없지만 괄호를 사용하면 텍스트를 읽기 쉽습니다.

PL/SQL의 연산자
예제:
y 루프 카운터를 증가시킵니다.
v_count := v_count + 1;
y 부울 플래그의 값을 설정합니다.
v_equal := (v_n1 = v_n2);
y 사원 번호에 값이 있는지 확인합니다.

v_valid := (v_empno IS NOT NULL);
n l y
e O
PL/SQL의 연산자
U s
널을 다룰 때 다음 규칙을 기억하면 많은 실수를 피할 수 있습니다.
y 널을 포함하는 비교 결과는 항상 NULL입니다.
A I
y 널에 논리 연산자 NOT을 적용하면 결과는 NULL이 됩니다.
O
&
y 조건 제어문에서 조건의 결과가 NULL이면 연관된 명령문 시퀀스가 실행되지 않습니다.
l
n a
te r
I n
c le
r a
O

프로그래밍 지침
다음을 수행하면 코드를 쉽게 유지 관리할 수 있습니다.

y 주석을 사용하여 코드 설명 기록
y 코드에 대한 대소문자 규칙 사용
y 식별자와 기타 객체에 대한 이름 지정 규칙 개발
y 들여쓰기를 사용하여 가독성 향상
n l y
e O
프로그래밍 지침
U s
PL/SQL 블록을 작성할 때 명확한 코드를 작성하고 유지 관리 작업을 줄이려면 슬라이드의
프로그래밍 지침을 따르십시오.
A I
코드 작성 규칙
O
대소문자 사용 지침을 제공합니다.
l &
다음 표에서는 이름이 지정된 객체와 키워드를 구별하는 데 도움이 되도록 코드에 대한
n a
범주
SQL 문
te r
대소문자 규칙
대문자
예제
n
SELECT, INSERT
PL/SQL 키워드
e I 대문자 DECLARE, BEGIN, IF
데이터 유형
cl 대문자 VARCHAR2, BOOLEAN
식별자와 파라미터
Ora
데이터베이스 테이블과 열
소문자
소문자
v_sal, emp_cursor, g_sal,
p_empno
employees, employee_id,
department_id

코드 들여쓰기
코드의 각 레벨을 들여써서 명확하게 작성합니다.

예제: DECLARE
v_deptno NUMBER(4);
BEGIN v_location_id NUMBER(4);
IF x=0 THEN BEGIN
y:=1; SELECT department_id,
END IF; location_id
END; INTO v_deptno,
v_location_id
FROM departments
WHERE department_name
= 'Sales';
...
END;
/
n l y
e O
코드 들여쓰기
U s
코드를 읽기 쉽고 명확하게 하기 위해 레벨에 따라 코드를 들여쓰십시오. 구조를 표시하려면
캐리지 리턴을 사용하여 행을 나누고 공백이나 탭을 사용하여 들여쓰면 됩니다. 다음 IF 문을
A I
비교해 보면 쉽게 이해할 수 있습니다.
IF x>y THEN v_max:=x;ELSE v_max:=y;END IF; O
l &
IF x > y THEN
n a
v_max := x;
te r
n
ELSE
v_max := y;
e I
END IF;
c l
r a
O

요약

y PL/SQL 블록의 구문 및 지침
y 식별자의 올바른 사용법
y PL/SQL 블록 구조: 블록 중첩 및 범위 지정 규칙
y PL/SQL 프로그래밍:
− 함수 …
DECLARE
− 데이터 유형 변환
…
BEGIN
−
−
연산자
규칙과 지침
…
EXCEPTION
END;
n l y
e O
요약
U s
PL/SQL은 SQL의 기능을 확장한 것이므로 SQL에 적용되는 일반 구문 규칙은 PL/SQL 언어에도
적용됩니다.
A I
O
식별자는 상수, 변수, 예외 사항, 커서, 커서 변수, 서브 프로그램 및 패키지를 포함한 PL/SQL
프로그램 항목 및 단위의 이름을 지정하는 데 사용합니다.
l &
블록의 실행 부분에 여러 개의 중첩 블록을 정의할 수 있습니다. 블록 내에 정의된 블록을 서브
블록이라고 하며 블록의 실행 부분에서만 블록을 중첩할 수 있습니다.
n a
te r
PL/SQL 표현식에는 SQL의 함수 대부분을 사용할 수 있습니다. 변환 함수는 값의 데이터 유형을
다른 데이터 유형으로 변환합니다. 일반적으로 변환 함수는 data type TO data type의 형식을
데이터 유형입니다.
I n
사용합니다. 여기서 첫번째 데이터 유형은 입력 데이터 유형이고 두번째 데이터 유형은 출력
le
비교 연산자는 한 표현식을 다른 표현식과 비교합니다. 결과는 항상 TRUE, FALSE, NULL 중
c
하나입니다. 일반적으로 SQL 데이터 조작문의 WHERE 절 및 조건 제어문에서 비교 연산자를
ra
사용합니다. 관계 연산자를 사용하면 복잡한 표현식을 임의로 비교할 수 있습니다.
O
iSQL*Plus에 선언된 변수를 바인드 변수라고 합니다. PL/SQL 프로그램에서 바인드 변수를
참조하려면 변수에 콜론을 접두어로 붙여야 합니다.

연습 2 개요

y 범위 지정 및 중첩 규칙 복습
y PL/SQL 블록의 개발 및 테스트
n l y
e O
연습 2 개요
U s
이 연습을 통해 이 단원에서 설명한 PL/SQL의 기본적인 내용을 보충할 수 있습니다. 연습에서는
PL/SQL 블록 예제를 사용하여 범위 지정 규칙에 대한 이해도를 테스트하고 PL/SQL 블록을 직접
A I
작성해 볼 수 있도록 합니다.
문제 O
문제 1과 2는 실습이 필요 없는 간단한 문제입니다.
l &
n a
te r
I n
c le
ra
O

연습 2
PL/SQL 블록
DECLARE
v_weight NUMBER(3) := 600;
v_message VARCHAR2(255) := 'Product 10012';
BEGIN
DECLARE
v_weight NUMBER(3) := 1;
v_message VARCHAR2(255) := 'Product 11001';
v_new_locn VARCHAR2(50) := 'Europe';
BEGIN
v_weight := v_weight + 1;
v_new_locn := 'Western ' || v_new_locn;
1
END;
v_weight := v_weight + 1;
v_message := v_message || ' is in stock';
v_new_locn := 'Western ' || v_new_locn;
n l y
e O
2
END;
U s
/
A
1. 위에 있는 PL/SQL 블록을 평가하고 범위 규칙에 따라 다음 각 변수의 값과 데이터 유형을
I
검토하십시오. O
a. 1번 위치에서 V_WEIGHT의 값:
l &
n a
r
b. 1번 위치에서 V_NEW_LOCN의 값:
te
I n
c. 2번 위치에서 V_WEIGHT의 값:
c l e
d. 2번 위치에서 V_MESSAGE의 값:
r a
O e. 2번 위치에서 V_NEW_LOCN의 값:

연습 2(계속)
범위 예제
DECLARE
v_customer VARCHAR2(50) := 'Womansport';
v_credit_rating VARCHAR2(50) := 'EXCELLENT';
BEGIN
DECLARE
v_customer NUMBER(7) := 201;
v_name VARCHAR2(25) := 'Unisports';
BEGIN
v_customer v_name v_credit_rating
END;
v_customer v_name v_credit_rating
END;
/
2. 위의 예제에서 보듯이 블록 안에 서브 블록이 있고 주 블록에서는 두 변수 V_CUSTOMER
및 V_CREDIT_RATING을 선언하고, 서브 블록에서는 두 변수 V_CUSTOMER 및 V_NAME을
선언합니다. 다음 각 경우의 값과 데이터 유형을 검토하십시오.
a. 서브 블록에 있는 V_CUSTOMER의 값:
n l y
b. 서브 블록에 있는 V_NAME의 값:
e O
U s
c. 서브 블록에 있는 V_CREDIT_RATING의 값:
A I
d. 주 블록에 있는 V_CUSTOMER의 값:
O
l &
e. 주 블록에 있는 V_NAME의 값:
n a
te r
f. 주 블록에 있는 V_CREDIT_RATING의 값:
I n
c l e
r a
O

연습 2(계속)
3. iSQL*Plus 치환 변수를 통해 두 개의 숫자를 받아들이는 PL/SQL 블록을 작성하고
실행하십시오.
a. DEFINE 명령을 사용해 두 값을 제공하십시오.
DEFINE p_num1 = 2
DEFINE p_num2 = 4
b. 위 단계에서 정의한 두 값을 iSQL*Plus 치환 변수를 통해 PL/SQL 블록으로 전달한 다음
첫번째 숫자를 두번째 숫자로 나누고 그 결과에 두번째 숫자를 더하십시오. 그런 다음
결과를 PL/SQL 변수에 저장하고 화면에 출력하십시오.
참고: PL/SQL 블록에 SET VERIFY OFF를 설정하십시오.
4. 연간 총수입을 계산하는 PL/SQL 블록을 작성하십시오.

a. DEFINE 명령을 사용하여 연봉과 상여금율 값을 정의하십시오.
b. 위 단계에서 정의한 값을 iSQL*Plus 치환 변수를 통해 PL/SQL 블록으로 전달하십시오.
상여금은 정수에서 소수로(예를 들어 15에서 .15로) 변환해야 합니다. 급여가 널이면
총수입을 계산하기 전에 0으로 설정한 후 PL/SQL 블록을 실행하십시오. 참고: 널 값을
처리할 때는 NVL 함수를 사용하십시오.
참고: 총수입은 연봉과 상여금의 합계입니다.
n l y
NVL 함수를 테스트하려면 DEFINE 변수를 NULL로 설정합니다.
DEFINE p_salary = 50000
e O
DEFINE p_bonus = 10
U s
A I
O
l &
n a
te r
I n
c l e
r a
O

Oracle Server와의
상호 작용
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y PL/SQL에서 올바른 SELECT 문 작성
y PL/SQL에서 DML 문 작성
y PL/SQL에서 트랜잭션 제어
y SQL DML(데이터 조작어) 문의 결과 판독
n l y
e O
단원 목표
U s
이 단원에서는 PL/SQL 블록에 표준 SQL 문인 SELECT, INSERT, UPDATE 및 DELETE 문을
넣는 방법과, PL/SQL에서의 트랜잭션 제어 방법 및 SQL DML 문의 결과 판독 방법을
설명합니다. A I
O
l &
n a
te r
I n
c le
r a
O
PL/SQL의 SQL 문
y SELECT 명령을 사용하여 데이터베이스에서 데이터

행(row)을 추출합니다.
y DML 명령을 사용하여 데이터베이스의 행(row)을
변경합니다.
y COMMIT, ROLLBACK, SAVEPOINT 명령을 사용하여
트랜잭션을 제어합니다.
y 암시적(implicit) 커서 속성을 사용하여 DML 결과를
판독합니다.
n l y
e O
PL/SQL의 SQL 문
U s
데이터베이스에서 정보를 추출하거나 데이터베이스의 내용을 변경하려면 SQL을 사용해야
합니다. PL/SQL은 SQL의 DML 문(데이터 조작어)과 트랜잭션 제어 명령을 지원합니다.
SELECT 문을 사용하여 테이블의 행(row)에서 질의한 값을 변수에 넣을 수 있고, DML 명령을 A I
사용하면 데이터베이스 테이블의 데이터를 수정할 수 있습니다. 하지만 PL/SQL 블록에 DML
O
l &
문 및 트랜잭션 제어 명령을 사용할 때는 PL/SQL 블록에 관한 다음 사항들을 기억하십시오.
y 키워드 END는 트랜잭션의 끝이 아니라 PL/SQL 블록의 끝을 나타냅니다. 한 블록 내에
n a
여러 트랜잭션이 있을 수 있는 것처럼 한 트랜잭션 내에도 여러 블록이 있을 수 있습니다.
te r
y PL/SQL은 CREATE TABLE, ALTER TABLE, DROP TABLE 등의 DDL(데이터 정의어)
문을 직접 지원하지 않습니다.
I n
y PL/SQL은 GRANT 또는 REVOKE 등의 DCL(데이터 제어어) 문을 지원하지 않습니다.
c l e
r a
O
PL/SQL의 SELECT 문
SELECT 문을 사용하여 데이터베이스에서 데이터를

검색합니다.
구문:
SELECT select_list
INTO {variable_name[, variable_name]...
| record_name}
FROM table
[WHERE condition];
n l y
e O
PL/SQL을 사용하여 데이터 검색
U s
SELECT 문을 사용하여 데이터베이스에서 데이터를 검색합니다.
구문 설명:
A I
select_list 하나 이상의 열로 구성된 목록이며 SQL 표현식, 행(row) 함수 또는 그룹 함수
O
등을 포함할 수 있습니다.
검색한 값을 보유하는 스칼라 변수입니다.
l &
variable_name
n a
record_name
table
te r
검색한 값을 보유하는 PL/SQL 레코드입니다.
데이터베이스 테이블 이름을 지정합니다.
condition
I n
PL/SQL 변수와 상수를 비롯한 열 이름, 표현식, 상수 및 비교 연산자로
구성됩니다.
c l
PL/SQL에서의 데이터 검색에 대한 지침
e
r a
y 각 SQL 문은 세미콜론(;)으로 종료해야 합니다.
O
y PL/SQL에 SELECT 문을 넣을 경우 INTO 절이 필요합니다.
y WHERE 절은 선택 사항이며 입력 변수, 상수, 리터럴, PL/SQL 표현식을 지정하는 데
사용됩니다.

PL/SQL을 사용하여 데이터 검색(계속)
y INTO 절의 변수 개수는 SELECT 절의 데이터베이스 열 수와 동일해야 합니다.
또한 변수 위치가 대응되고 데이터 유형이 호환되어야 합니다.
y 그룹 함수는 테이블의 행 그룹에 적용되므로 SQL 문에 SUM과 같은 그룹 함수를
사용하십시오.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O
y INTO 절은 필수 항목입니다.
y 질의는 하나의 행(row)을 반드시 반환해야 합니다.
예제:
DECLARE
v_deptno NUMBER(4);
v_location_id NUMBER(4);
BEGIN
SELECT department_id, location_id
INTO v_deptno, v_location_id
FROM departments
WHERE department_name = 'Sales';
...
END;
/
n l y
e O
U s
INTO 절
INTO 절은 필수 항목으로서 SELECT 절과 FROM 절 사이에 위치하며, SQL이 SELECT 절에서
A I
반환하는 값을 보유할 변수 이름을 지정하는 데 사용됩니다. 선택한 항목 당 하나의 변수를
지정해야 하며 변수의 순서는 선택한 항목과 대응되어야 합니다. O
l
INTO 절을 사용하여 PL/SQL 변수 또는 호스트 변수에 값을 넣습니다.&
질의는 하나의 행(row)을 반드시 반환해야 합니다.
n a
te r
PL/SQL 블록의 SELECT 문은 “질의는 하나의 행을 반드시 반환해야 한다”는 규칙이
적용되어야 ANSI 표준 내장 SQL로 분류됩니다. 여러 행을 반환하거나 한 행도 반환하지
않으면 오류가 발생합니다.
I n
PL/SQL은 표준 예외 사항을 발생시켜 이런 오류를 관리하며, NO_DATA_FOUND 및
le
TOO_MANY_ROWS 예외 사항을 통해 블록의 예외 부분에서 오류를 처리합니다(예외 처리는
c
다음 단원에서 설명). SELECT 문을 코딩하면 단일 행(row)을 반환해야 합니다.
r a
O
PL/SQL에서 데이터 검색
지정된 사원의 입사일과 급여를 검색합니다.
예제:
DECLARE
v_hire_date employees.hire_date%TYPE;
v_salary employees.salary%TYPE;
BEGIN
SELECT hire_date, salary
INTO v_hire_date, v_salary
FROM employees
...
END;
/
n l y
e O
U s
슬라이드의 예제에서는 v_hire_date와 v_salary 변수를 PL/SQL 블록의 DECLARE
섹션에서 선언합니다. 실행 부분에서는 EMPLOYEE_ID가 100인 직원의 HIRE_DATE 및
SALARY 열 값을 EMPLOYEES 테이블에서 검색하여 v_hire_date와 v_salary 변수에 각각 A I
저장합니다. SELECT 문과 INTO 절을 이용해 데이터베이스 열 값을 검색하고 검색된 값을
O
PL/SQL 변수에 넣는 방식을 눈여겨보십시오.
l &
n a
te r
I n
c le
r a
O
지정된 부서에 속한 모든 사원의 급여 총액을 반환합니다.
예제:
SET SERVEROUTPUT ON
DECLARE
v_sum_sal NUMBER(10,2);
v_deptno NUMBER NOT NULL := 60;
BEGIN
SELECT SUM(salary) -- group function
INTO v_sum_sal
FROM employees
WHERE department_id = v_deptno;
DBMS_OUTPUT.PUT_LINE ('The sum salary is ' ||
TO_CHAR(v_sum_sal));
END;
/
n l y
e O
U s
슬라이드의 예제에서는 v_sum_sal과 v_deptno 변수를 PL/SQL 블록의 DECLARE 섹션에서
선언합니다. 실행 부분에서는 SQL 집계 함수인 SUM을 사용해서 DEPARTMENT_ID가 60인
부서의 급여 총액을 계산하여 v_sum_sal에 할당합니다. PL/SQL 구문에는 그룹 함수를 A I
사용할 수 없으므로 PL/SQL 블록 내의 SQL 문에서 사용하였습니다.
O
슬라이드에 있는 PL/SQL 블록의 출력은 다음과 같습니다.
l &
n a
te r
I n
c l e
r a
O
DECLARE
hire_date employees.hire_date%TYPE;
sysdate hire_date%TYPE;
employee_id employees.employee_id%TYPE := 176;
BEGIN
SELECT hire_date, sysdate
INTO hire_date, sysdate
FROM employees
WHERE employee_id = employee_id;
END;
/
n l y
e O
U s
명확하게 지정되지 않은 SQL 문에서는 데이터베이스 열의 이름이 지역 변수의 이름보다
우선순위가 높습니다. 슬라이드의 예제는 EMPLOYEES 테이블에서 직원 ID가 176인 사람의
입사일과 오늘 날짜를 검색하도록 정의되어 있습니다. 그러나 WHERE 절의 PL/SQL 변수 A I
이름이 EMPLOYEES 테이블의 데이터베이스 열 이름과 동일하기 때문에 이 예제에서는
O
처리되지 않은 런타임 예외 사항이 발생합니다.
l &
n a
다음의 DELETE 문에서는 Oracle Server가 WHERE 절의 두 LAST_NAME 절이 모두 데이터베이스
열을 참조하는 것으로 간주하기 때문에, EMPLOYEES 테이블에서 성이 ‘King’인 직원이 아니라
널이 아닌 모든 직원들이 제거됩니다.
te r
DECLARE
I n
l e
last_name VARCHAR2(25) := 'King';
BEGIN
c
r a
DELETE FROM employees WHERE last_name = last_name;
. . .
O
PL/SQL을 사용하여 데이터 조작
DML 명령을 사용하여 데이터베이스 테이블을 변경합니다.
y INSERT
y UPDATE INSERT
y DELETE
M
y MERGE ER
UPDATE GE
DELETE
n l y
e O
PL/SQL을 사용하여 데이터 조작
U s
데이터베이스의 데이터는 DML 명령을 사용하여 조작할 수 있습니다. PL/SQL에서는 DML
명령인 INSERT, UPDATE, DELETE를 아무런 제한 없이 실행할 수 있습니다. PL/SQL 코드에
COMMIT 또는 ROLLBACK 문을 포함시키면 행 잠금(row lock) 및 테이블 잠금이 해제됩니다. A I
y INSERT 문은 테이블에 새로운 데이터 행(row)을 추가합니다. O
y UPDATE 문은 테이블의 기존 행(row)을 수정합니다.
l &
y DELETE 문은 테이블에서 필요 없는 행(row)을 제거합니다.
n a
te r
y MERGE 문은 한 테이블의 행(row)을 선택하여 다른 테이블로 갱신하거나 삽입합니다.
대상 테이블로 갱신할 것인지 삽입할 것인지의 여부는 ON 절의 조건에 따라 결정됩니다.
I n
참고: MERGE는 결정문입니다. 즉 동일한 MERGE 문에서 대상 테이블의 동일한 행(row)을 여러
le
번 갱신할 수 없습니다. 또한 대상 테이블에 대해 INSERT 및 UPDATE 객체 권한이 있어야 하며
소스 테이블에 대해서는 SELECT 권한이 있어야 합니다.
c
r a
O
데이터 삽입
EMPLOYEES 테이블에 신입 사원 정보를 추가합니다.
예제:
BEGIN
INSERT INTO employees
(employee_id, first_name, last_name, email,
hire_date, job_id, salary)
VALUES
(employees_seq.NEXTVAL, 'Ruth', 'Cores', 'RCORES',
sysdate, 'AD_ASST', 4000);
END;
/
n l y
e O
데이터 삽입
U s
슬라이드의 예에서는 PL/SQL 블록 내에 INSERT 문을 사용하여 EMPLOYEES 테이블에
레코드를 삽입합니다. PL/SQL 블록에서 INSERT 명령을 사용하면 다음을 수행할 수 있습니다.
A I
y USER 및 SYSDATE 같은 SQL 함수를 사용합니다.
y 데이터베이스 시퀀스를 사용하여 기본 키 값을 생성합니다. O
y PL/SQL 블록에서 값을 구합니다.
l &
y 열 기본값을 추가합니다.
n a
te r
참고: 문에서는 열 이름과 식별자를 혼동할 가능성이 없습니다. INSERT 절의 모든 식별자는
데이터베이스 열 이름이어야 합니다.
I n
c le
r a
O
데이터 갱신
모든 주식 담당 사원의 급여를 인상합니다.
예제:
DECLARE
v_sal_increase employees.salary%TYPE := 800;
BEGIN
UPDATE employees
SET salary = salary + v_sal_increase
WHERE job_id = 'ST_CLERK';
END;
/
n l y
e O
데이터 갱신
U s
UPDATE 문의 SET 절에서 할당 연산자의 왼쪽에 있는 식별자는 항상 데이터베이스 열이지만
오른쪽에 있는 식별자는 데이터베이스 열 또는 PL/SQL 변수일 수 있으므로 불명확한 점이
A I
있을 수 있습니다.
O
PL/SQL의 SELECT 문과는 달리 오류가 발생하지 않습니다.
l &
WHERE 절은 영향을 받는 행(row)을 결정하는 데 사용됩니다. 행(row)이 수정되지 않아도
n a
참고: PL/SQL 변수 할당에는 항상 :=을 사용하고 SQL 열 할당에는 항상 =을 사용합니다.
te r
WHERE 절에 있는 열 이름과 식별자 이름이 동일한 경우 Oracle Server는 먼저
데이터베이스에서 해당 이름을 검색한다는 점에 유의하십시오.
I n
c le
r a
O
데이터 삭제
EMPLOYEES 테이블에서 부서 10에 속하는 행(row)을

삭제합니다.
예제:
DECLARE
v_deptno employees.department_id%TYPE := 10;
BEGIN
WHERE department_id = v_deptno;
END;
/
n l y
e O
데이터 삭제
U s
DELETE 문은 테이블에서 불필요한 행(row)을 삭제합니다. 무결성 제약 조건이 없을 때 WHERE
절을 사용하지 않으면 테이블의 내용 전체가 삭제될 수 있습니다.
A I
O
l &
n a
te r
I n
c le
r a
O
행 병합
COPY_EMP 테이블에 행(row)을 삽입 또는 갱신하여
EMPLOYEES 테이블과 일치시킵니다.
DECLARE
v_empno employees.employee_id%TYPE := 100;
BEGIN
MERGE INTO copy_emp c
USING employees e
ON (e.employee_id = v_empno)
WHEN MATCHED THEN
UPDATE SET
c.first_name = e.first_name,
c.last_name = e.last_name,
c.email = e.email,
. . .
WHEN NOT MATCHED THEN
INSERT VALUES(e.employee_id, e.first_name, e.last_name,
. . .,e.department_id);
y
END;
n l
e O
행 병합
U s
MERGE 문은 다른 테이블의 데이터를 사용하여 테이블에 행(row)을 삽입 또는 갱신합니다.
각 행은 등가 조인 조건에 따라 대상 테이블로 삽입 또는 갱신됩니다.
A I
O
예제에서는 COPY_EMP 테이블의 employee_id를 EMPLOYEES 테이블의 employee_id에
일치시킵니다. 일치되는 대상 행이 있으면 EMPLOYEES의 행과 동일하게 갱신됩니다. 해당
행이 없으면 COPY_EMP 테이블에 행이 삽입됩니다.
l &
a
PL/SQL 블록에서 MERGE를 사용하는 전체 예제는 다음 페이지에서 소개합니다.
n
te r
I n
c l e
r a
O
데이터 병합
DECLARE
v_empno EMPLOYEES.EMPLOYEE_ID%TYPE := 100;
BEGIN
MERGE INTO copy_emp c
USING employees e
ON (e.employee_id = v_empno)
WHEN MATCHED THEN
UPDATE SET
c.first_name = e.first_name,
c.last_name = e.last_name,
c.email = e.email,
c.phone_number = e.phone_number,
c.hire_date = e.hire_date,
c.job_id = e.job_id,
c.salary = e.salary,
c.commission_pct = e.commission_pct,
n l y
c.manager_id = e.manager_id,
e O
c.department_id
WHEN NOT MATCHED THEN
= e.department_id
U s
INSERT VALUES(e.employee_id,
I
e.first_name, e.last_name,
A
e.email, e.phone_number, e.hire_date, e.job_id,
O
e.salary, e.commission_pct, e.manager_id,
e.department_id);
l &
END;
n a
/
te r
I n
c l e
r a
O
y 이름 지정 규칙을 사용하여 WHERE 절을 명확하게

합니다.
y 데이터베이스 열 이름과 식별자 이름은 달라야 합니다.
y PL/SQL은 먼저 데이터베이스에서 테이블의 열을
확인하기 때문에 구문 오류가 발생할 수 있습니다.
y 지역 변수와 형식 매개변수의 이름은 데이터베이스
테이블의 이름보다 우선순위가 높습니다.
y 데이터베이스 테이블 열의 이름은 지역 변수의
이름보다 우선순위가 높습니다.
n l y
e O
U s
PL/SQL 변수 이름과 데이터베이스 열 이름을 구분하는 이름 지정 규칙을 적용하여 WHERE 절
부분을 명확하게 합니다.
A I
y 데이터베이스 열 이름과 식별자 이름은 달라야 합니다.
y PL/SQL은 먼저 데이터베이스에서 테이블의 열을 확인하기 때문에 구문 오류가 발생할 O
수 있습니다.
l &
n a
te r
I n
c le
r a
O
이름 지정 규칙(계속)
다음 표에서는 식별자를 다른 식별자, 데이터베이스 객체 및 기타 명명된 객체와 구분하는
접두어 및 접미어를 소개합니다.
식별자 이름 지정 규칙 예제
변수 v_name v_sal
상수 c_name c_company_name
커서 name_cursor emp_cursor
예외 사항 e_name e_too_many
테이블 유형 name_table_type amount_table_type
테이블 name_table countries
레코드 유형 name_record_type emp_record_type
레코드 name_record customer_record
iSQL*Plus 치환 변수(치환 p_name p_sal

파라미터라고도 함)
iSQL*Plus 호스트 변수 또는
바인드 변수
g_name g_year_sal
n l y
e O
많은 경우 코드를 좀더 명확하게 작성하게 하기 위해 다음과 같이 지역 변수와 형식
매개변수의 이름에 v_를 접두어로 붙입니다.
U s
DECLARE
v_last_name VARCHAR2(25);
A I
O
참고: SELECT 절의 모든 식별자는 데이터베이스 열 이름이므로 혼동할 가능성이 없고 INTO
&
절의 식별자는 PL/SQL 변수이므로 역시 혼동할 가능성이 없으나 WHERE 절에서는 혼동될 수
l
있습니다.
n a
te r
I n
c l e
r a
O
SQL 커서
y 커서는 전용(private) SQL 작업 영역입니다.

y 커서에는 다음 두 가지 유형이 있습니다.
− 암시적 커서(implicit cursor)
− 명시적 커서(explicit cursor)
y Oracle Server는 암시적 커서를 사용하여 SQL 문의
구문을 분석하고 실행합니다.
y 명시적 커서는 프로그래머가 명시적으로 선언합니다.
n l y
e O
SQL 커서
U s
SQL 문을 실행할 때마다 Oracle Server는 메모리 영역을 열어 해당 명령의 구문을 분석하고
실행하는 데 이 영역을 커서라고 합니다.
A I
O
블록의 실행 부분에서 SQL 문을 실행하면 PL/SQL은 암시적 커서(implicit cursor)를 작성하여
자동으로 관리합니다. 명시적 커서(explicit cursor)는 프로그래머가 명시적으로 선언하고
&
이름을 지정합니다. PL/SQL에는 커서에 적용할 수 있는 네 가지 속성이 있습니다.
l
a
참고: 명시적 커서(explicit cursor)에 대한 자세한 내용은 다음 단원에서 설명합니다.
n
r
자세한 내용은 PL/SQL User's Guide and Reference, “Interaction with Oracle”을 참조하십시오.
te
I n
c l e
r a
O
SQL 커서 속성
SQL 커서 속성을 사용하면 SQL 문의 결과를 검사할 수

있습니다.
SQL%ROWCOUNT 가장 최근의 SQL 문에 의해 영향을 받은
행(row)의 개수(정수 값)입니다.
SQL%FOUND 가장 최근의 SQL 문이 하나 이상의 행
(row)에 영향을 준 경우 TRUE로 평가되는
부울 속성입니다.
SQL%NOTFOUND 가장 최근의 SQL 문이 영향을 준 행(row)
이 없는 경우 TRUE로 평가되는 부울
속성입니다.
SQL%ISOPEN PL/SQL은 암시적 커서(implicit cursor)
를 실행 후 곧바로 닫기 때문에 항상
FALSE로 평가됩니다.
n l y
e O
SQL 커서 속성
SQL 커서 속성을 사용하면 마지막으로 암시적 커서를 사용했을 때 발생한 작업을 평가할 수
U s
있습니다. 이 속성은 SQL 문이 아니라 PL/SQL 문에 사용됩니다.
블록의 EXCEPTION 섹션에서 SQL%ROWCOUNT, SQL%FOUND, SQL%NOTFOUND 및 A I
SQL%ISOPEN 속성을 사용하여 DML 문의 실행에 대한 정보를 모을 수 있습니다. PL/SQL은
O
SELECT 문에서 검색된 행(row)이 없을 때에는 예외 사항을 반환합니다.
l &
DML 문이 기본 테이블의 행(row)에 영향을 주지 않을 때 오류를 반환하지 않습니다. 그러나
n a
te r
I n
c le
r a
O
SQL 커서 속성
EMPLOYEES 테이블에서 지정한 사원 번호를 가진

행(row)을 삭제하고 삭제된 행(row)의 개수를 출력합니다.
예제:
VARIABLE rows_deleted VARCHAR2(30)
DECLARE
v_employee_id employees.employee_id%TYPE := 176;
BEGIN
WHERE employee_id = v_employee_id;
:rows_deleted := (SQL%ROWCOUNT ||
' row deleted.');
END;
/
PRINT rows_deleted
n l y
e O
SQL 커서 속성(계속)
U s
슬라이드의 예제에서는 EMPLOYEES 테이블에서 EMPLOYEE_ID가 176인 행(row)을
삭제합니다. SQL%ROWCOUNT 속성을 사용하면 삭제된 행(row)의 개수를 출력할 수 있습니다.
A I
O
l &
n a
te r
I n
c le
r a
O
트랜잭션 제어문
y 트랜잭션은 COMMIT 또는 ROLLBACK 다음에 이어지는

첫번째 명령으로 시작됩니다.
y COMMIT 및 ROLLBACK 문을 사용하여 트랜잭션을
명시적으로(explicitly) 종료합니다.
n l y
e O
트랜잭션 제어문
U s
COMMIT 및 ROLLBACK SQL 문을 사용하면 트랜잭션의 논리를 제어하여 일부 데이터베이스
변경 내용은 영구히 저장하고 다른 내용은 되돌릴 수 있습니다. Oracle Server에서와 같이 DML
트랜잭션은 COMMIT 또는 ROLLBACK 다음에 이어지는 첫번째 명령에서 시작하여 그 다음에 A I
성공적으로 수행된 COMMIT 또는 ROLLBACK에서 종료됩니다. 이 작업은 PL/SQL 블록 내에서
O
l &
수행되거나 호스트 환경에서 발생한 이벤트의 결과로 수행됩니다. 예를 들어, iSQL*Plus
세션을 종료하면 보류 중인 트랜잭션이 자동으로 커밋됩니다. 트랜잭션 처리 중 중간점을
표시하려면 SAVEPOINT를 사용하십시오.
n a
COMMIT [WORK];
te
SAVEPOINT savepoint_name;
r
ROLLBACK [WORK];
I n
설명:
c le
ROLLBACK [WORK] TO [SAVEPOINT] savepoint_name;
WORK ANSI 표준을 준수합니다.
r a
참고: 트랜잭션 제어 명령을 호스트 환경에서 사용하면 제한 사항이 있을 수 있지만
O
PL/SQL에서는 모두 사용할 수 있습니다.
블록에는 명시적(explicit) 잠금 명령(예: LOCK TABLE 및 SELECT ... FOR UPDATE)도
사용할 수 있으며 이 명령은 트랜잭션을 종료할 때까지 유효합니다(FOR UPDATE 명령은 다음
단원에서 설명). 또한 PL/SQL 블록 하나가 반드시 하나의 트랜잭션에 대응되는 것은 아닙니다.

요약
이 단원에서는 다음과 같은 작업을 수행하는 방법에 대해

배웠습니다.
y PL/SQL 블록에 SQL 삽입: SELECT, INSERT,
UPDATE, DELETE 및 MERGE
y PL/SQL 블록에 트랜잭션 제어문 삽입: COMMIT,
ROLLBACK 및 SAVEPOINT
n l y
e O
요약
U s
DML 명령인 INSERT, UPDATE, DELETE 및 MERGE는 PL/SQL 프로그램에서 아무런 제한 없이
사용할 수 있습니다. COMMIT 문은 현재 트랜잭션을 종료하고 해당 트랜잭션에서 발생한 모든
변경 내용을 영구히 저장하는 반면, ROLLBACK 문은 현재 트랜잭션을 종료하고 해당 A I
트랜잭션에서 발생한 모든 변경 내용의 실행을 취소하며, SAVEPOINT는 트랜잭션 처리 중에
O
트랜잭션의 전체가 아닌 일부의 실행을 취소할 수 있습니다.
l &
현재 위치의 이름을 지정하고 표시합니다. ROLLBACK TO SAVEPOINT 문을 사용하면
n a
te r
I n
c le
r a
O
요약

y 커서에는 암시적 커서(implicit cursor)와 명시적
커서(explicit cursor)의 두 가지 유형이 있습니다.
y 암시적 커서의 속성으로 DML 문의 결과를 판독할 수
있습니다.
− SQL%ROWCOUNT
− SQL%FOUND
− SQL%NOTFOUND
− SQL%ISOPEN
y 명시적 커서는 프로그래머가 정의합니다.
n l y
e O
요약(계속)
U s
PL/SQL에서 암시적 커서(implicit cursor)는 각 SQL DML 문에 대해 선언됩니다. 암시적
커서에는 %FOUND, %ISOPEN, %NOTFOUND, %ROWCOUNT의 네 가지 속성이 있습니다. 이런
변수를 커서나 커서 변수에 추가하면 DML 문의 실행에 대한 유용한 정보가 반환됩니다. 커서 A I
속성은 프로시저문에만 사용할 수 있고 SQL 문에는 사용할 수 없습니다. 명시적 커서(explicit
O
cursor)는 프로그래머가 정의합니다.
l &
n a
te r
I n
c l e
r a
O
연습 3 개요
이 연습에서는 PL/SQL 블록을 작성하여 다음 작업을

수행하는 방법을 다룹니다.
y 테이블에서 데이터 선택
y 테이블에 데이터 삽입
y 테이블의 데이터 갱신
y 테이블에서 레코드 삭제
n l y
e O
연습 3 개요
U s
이 연습에서는 PL/SQL 블록에 있는 기본 SQL 질의문과 DML 문을 사용하여 테이블에서
정보를 선택, 입력, 갱신 및 삭제하는 PL/SQL 블록을 작성합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
연습 3
1. DEPARTMENTS 테이블에서 부서 번호 최대값을 선택하여 iSQL*Plus 변수로 저장하는
PL/SQL 블록을 작성하고 그 결과를 화면에 출력하십시오. 그런 다음 Save Script
버튼을 눌러 PL/SQL 블록을 p3ql.sql이라는 이름의 파일로 저장하십시오. 스크립트는
.sql 확장자로 저장합니다.
2. 연습 1에서 작성한 PL/SQL 블록을 수정하여 DEPARTMENTS 테이블에 새 부서를

삽입하십시오. 그런 다음 Save Script 버튼을 눌러 PL/SQL 블록을 p3q2.sql이라는
이름의 파일로 저장하십시오. 스크립트는 .sql 확장자로 저장합니다.
a. DEFINE 명령을 사용하여 부서 이름을 지정하십시오. Education을 새 부서의
이름으로 지정하십시오.
b. 부서 이름으로 지정된 값을 iSQL*Plus 치환 변수를 통해 PL/SQL 블록으로
전달하십시오. 연습 1에서 검색된 부서 번호를 출력하는 대신 그 번호에 10을
더하여 새 부서의 부서 번호로 사용하십시오.
c. 위치 번호는 일단 널로 두십시오.
d. PL/SQL 블록을 실행하십시오.
e. 새로 생성한 부서를 표시하십시오.
n l y
e O
U s
A I
3. 앞의 연습에서 추가한 새 부서의 위치 ID를 갱신하는 PL/SQL 블록을 작성하십시오. 그런
O
다음 Save Script 버튼을 눌러 PL/SQL 블록을 p3q3.sql이라는 이름의 파일로
l &
저장하십시오. 스크립트는 .sql 확장자로 저장합니다.
a. 앞의 연습에서 추가한 부서 ID 번호에 대한 iSQL*Plus 변수를 사용하십시오.
n a
b. DEFINE 명령을 사용하여 위치 ID를 지정하십시오. 새 위치 ID는 1700으로
지정하십시오.
te r
I n
DEFINE p_deptno = 280
DEFINE p_loc = 1700
le
c. 이 값을 iSQL*Plus 치환 변수를 통해 PL/SQL 블록으로 전달하고 PL/SQL 블록을
c테스트하십시오.
r a
d. 갱신된 부서를 표시하십시오.
O
연습 3(계속)
4. 연습 2에서 생성한 부서를 삭제하는 PL/SQL 블록을 작성하십시오. 그런 다음 Save
Script 버튼을 눌러 PL/SQL 블록을 p3q4.sql이라는 이름으로 저장하십시오.
스크립트는 .sql 확장자로 저장합니다.
a. DEFINE 명령을 사용하여 부서 ID를 지정하십시오.
DEFINE p_deptno=280
b. iSQL*Plus 치환 변수를 통해 값을 PL/SQL 블록으로 전달한 다음 영향을 받은
행(row)의 개수를 화면에 출력하십시오.
c. PL/SQL 블록을 테스트하십시오.
d. 부서가 삭제되었는지 확인하십시오.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
제어 구조 작성
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 제어 구조의 사용 및 유형 식별
y IF 문 구성
y CASE 표현식 사용
y 다른 루프 문의 구성 및 식별
y 논리 테이블 사용
y 중첩 루프와 레이블을 사용하여 블록 흐름 제어
n l y
e O
단원 목표
U s
이 단원에서는 IF 문과 루프를 사용한 PL/SQL 블록 내의 조건 제어에 대해 설명합니다.
A I
O
l &
n a
te r
I n
c le
ra
O

PL/SQL 실행 순서 제어
y 조건 IF 문과 루프 제어 구조를 사용하여 명령문의

논리적 실행 흐름을 변경할 수 있습니다.
y 조건 IF 문:
– IF-THEN-END IF
– IF-THEN-ELSE-END IF
– IF-THEN-ELSIF-END IF
n l y
e O
PL/SQL 실행 순서 제어
U s
여러 가지 제어 구조를 사용하여 PL/SQL 블록에 있는 명령문의 논리적 흐름을 변경할 수
있습니다. 이 단원에서는 PL/SQL 제어 구조의 세 가지 유형인 IF 문, CASE 표현식, LOOP 제어
A I
구조(이 단원 뒷부분에서 설명)를 사용한 조건 제어 구조를 다룹니다.
IF 문에는 다음 세 가지 유형이 있습니다. O
y IF-THEN-END IF
l &
y IF-THEN-ELSE-END IF
n a
y IF-THEN-ELSIF-END IF
te r
I n
c l e
r a
O

IF 문
구문:
IF condition THEN
statements;
[ELSIF condition THEN
statements;]
[ELSE
statements;]
END IF;
사원 이름이 Gietz이면 관리자 ID를 102로 설정합니다.

IF UPPER(v_last_name) = 'GIETZ' THEN
v_mgr := 102;
END IF;
n l y
e O
IF 문
U s
PL/SQL의 IF 문 구조는 다른 절차적 언어의 IF 문 구조와 유사합니다. PL/SQL에서 IF 문을
사용하면 조건에 따라 선택적으로 작업을 수행할 수 있습니다.
A I
구문 설명:
O
condition
&
부울 변수 또는 표현식입니다(TRUE, FALSE, NULL). 표현식의 결과가
l
TRUE일 경우에 실행되는 명령문 시퀀스와 연결되어 있습니다.
THEN
n a
선행하는 부울 표현식과 뒤따르는 명령문의 시퀀스를 연결하는 절입니다.
statements
r
하나 이상의 PL/SQL 문 또는 SQL 문이 올 수 있습니다. 또한 여러 개의
te
중첩된 IF, ELSE, ELSIF 문이 들어 있는 IF 문도 포함할 수 있습니다.
ELSIF
I n
부울 표현식을 도입하는 키워드입니다. 첫번째 조건의 결과가 FALSE
ELSE
c l e또는 NULL인 경우 ELSIF 키워드에 의해 추가 조건이 적용됩니다.
제어가 이 부분에 도달하면 뒤에 오는 명령문 시퀀스를 실행하는
r a 키워드입니다.

단순 IF 문
성이 Vargas인 경우:
y 업무 ID를 SA_REP로 설정합니다.
y 부서 번호를 80으로 설정합니다.
. . .
IF v_ename = 'Vargas' THEN
v_job := 'SA_REP';
v_deptno := 80;
END IF;
. . .
n l y
e O
단순 IF 문
U s
슬라이드의 예제에 있는 PL/SQL은 조건이 TRUE일 경우에만 다음 변수에 값을 할당합니다.
v_job과 v_deptno
A I
조건이 FALSE 또는 NULL이면, PL/SQL은 IF 블록의 명령문을 무시합니다. 두 경우 모두
O
프로그램의 END IF 다음에 오는 명령문으로 제어가 이동합니다.
지침
l &
n
y 만족하는 조건에 따라 선택적으로 작업을 수행할 수 있습니다.a
te r
y 코드를 작성할 때 다음 키워드의 철자를 기억해 두십시오.
I n
– ELSIF는 한 단어입니다.
l e
– END IF는 두 단어입니다.
c
y 부울 제어 조건이 TRUE면 연관된 명령문 시퀀스가 실행되고 부울 제어 조건이 FALSE
r a
또는 NULL이면 연관된 명령문 시퀀스가 실행되지 않습니다. ELSIF 절은 그 수에 제한이
O 없습니다.
y 조건적으로 실행되는 명령문은 알아보기 쉽도록 들여쓰기를 합니다.

혼합 IF 문
성이 Vargas이고 급여가 6500보다 많은 경우:

부서 번호를 60으로 설정합니다.
. . .
IF v_ename = 'Vargas' AND salary > 6500 THEN
v_deptno := 60;
END IF;
. . .
n l y
e O
혼합 IF 문
U s
혼합 IF 문에서는 AND나 NOT과 같은 논리 연산자가 사용됩니다. 슬라이드 예제의 IF 문에서는
다음 두 가지 조건이 평가됩니다.
A I
y 성이 Vargas인가?
O
y 급여가 6500보다 많은가?
l &
위의 두 가지 조건이 모두 TRUE로 평가되는 경우에만 v_deptno가 60으로 설정됩니다.
다음 예제를 살펴보겠습니다.
n a
. . .
te r
n
IF v_department = '60' OR v_hiredate > '01-Dec-1999' THEN
I
e
v_mgr := 101;
END IF;
c l
. . .
r a
O
앞의 예제에 있는 IF 문에는 평가할 조건이 두 개 있습니다.
y 부서 ID가 60인가?
y 입사일이 01-Dec-1999보다 큰가?
위 조건 중 하나가 TRUE로 평가되면 v_mgr은 101로 설정됩니다.

IF-THEN-ELSE 문 실행 흐름
TRUE TRUE 아님
IF 조건
THEN 작업 ELSE 작업
(추가 IF 문 포함) (추가 IF 문 포함)
n l y
e O
IF-THEN-ELSE 문 실행 흐름
U s
IF 생성자를 작성할 때, 조건이 FALSE 또는 NULL이면 ELSE 절을 사용하여 다른 작업을 수행할
수 있습니다. 단순 IF 문과 마찬가지로 END IF에서 제어가 재개됩니다. 예를 들면, 다음과
A I
같습니다.
IF condition1 THEN O
statement1;
l &
ELSE
statement2;
n a
END IF;
중첩 IF 문
te r
I n
특정 작업을 수행하기 전에, 첫번째 IF 문의 결과로 수행되는 두 작업 중 하나에 추가 IF 문을
l e
포함시킬 수 있습니다. THEN과 ELSE 절은 IF 문을 포함할 수 있으며 중첩 IF 문은 각각 해당
c
END IF로 종료해야 합니다.
r a
IF condition1 THEN
O statement1;
ELSE
IF condition2 THEN
statement2;
END IF;
END IF;

IF-THEN-ELSE 문
입사 후 5년이 넘었으면 부울 플래그를 TRUE로 설정하고

그렇지 않으면 부울 플래그를 FALSE로 설정합니다.
DECLARE
v_hire_date DATE := '12-Dec-1990';
v_five_years BOOLEAN;
BEGIN
. . .
IF MONTHS_BETWEEN(SYSDATE,v_hire_date)/12 > 5 THEN
v_five_years := TRUE;
ELSE
v_five_years := FALSE;
END IF;
...
n l y
e O
IF-THEN-ELSE 문: 예제
U s
슬라이드의 예제에서는 MONTHS_BETWEEN 함수를 사용하여 현재 날짜와 v_hire_date 변수
사이의 개월 수 차이를 계산합니다. 이 결과는 두 날짜 사이의 개월 수 차이이기 때문에 결과
값을 12로 나누어 연 단위로 변환합니다. 결과 값이 5보다 크면 부울 플래그가 TRUE로 설정되고 A I
그렇지 않으면 부울 플래그가 FALSE로 설정됩니다. O
l &
다음 예제를 살펴보겠습니다. 이 예제에서는 v_ename 변수를 검사하여 값이 King이면 v_job
a
변수를 AD_PRES로 설정하고, 그렇지 않으면 v_job 변수를 ST_CLERK으로 설정합니다.
n
te
IF v_ename = 'King' THENr
n
v_job := 'AD_PRES';
ELSE
v_job
e I
:= 'ST_CLERK';
END IF;
c l
r a
O

IF-THEN-ELSIF 문 실행 흐름
IF 조건
TRUE TRUE 아님
ELSIF
THEN 작업 조건
TRUE TRUE 아님
THEN 작업 ELSE
작업
n l y
e O
IF-THEN-ELSIF 문 실행 흐름
U s
몇 개의 상호 배타적 조건 중에 하나를 선택해야 할 경우가 있습니다. IF 문의 세번째 형태는
다음과 같이 ELSIF(ELSEIF가 아님) 키워드를 사용하여 추가 조건을 적용하는 것입니다.
A I
IF condition1 THEN
O
sequence_of_statements1;
ELSIF condition2 THEN
l &
n a
ELSE
te r
n
I
e
END IF;
c l
r a
O

IF-THEN-ELSIF 문 실행 흐름(계속)
첫번째 조건이 FALSE 또는 NULL이면 ELSIF 절은 다른 조건을 검사합니다. IF 문에는 여러
개의 ELSIF 절이 들어갈 수 있으며, 마지막 ELSE 절은 선택 사항입니다. 조건은 위에서 아래로
하나씩 평가됩니다. TRUE로 평가되는 조건이 있으면 그 조건과 연관된 명령문 시퀀스가
실행되며 제어는 다음 명령문으로 전달됩니다. 모든 조건이 FALSE 또는 NULL이면 ELSE 절의
시퀀스가 실행됩니다. 사원의 부서를 기준으로 하여 사원 상여금을 결정하는 다음 예제를
살펴보겠습니다.
IF v_deptno = 10 THEN
v_bonus := 5000;
ELSIF v_deptno = 80 THEN
v_bonus := 7500;
ELSE
v_bonus := 2000;
END IF;
참고: 여러 개의 IF-ELSIF 문이 있는 경우 첫번째 TRUE 문만 처리됩니다.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O

IF-THEN-ELSIF 문
값이 주어지면 조건에 따라 해당 값의 백분율을

계산합니다.
예제:
. . .
IF v_start > 100 THEN
v_start := 0.2 * v_start;
ELSIF v_start >= 50 THEN
ELSE
END IF;
. . .
n l y
e O
IF-THEN-ELSIF 문
U s
ELSIF 절은 중첩 IF 문의 코드보다 읽기와 이해하기가 쉽고 논리도 명확하게 알아볼 수
있으므로 가능하면 ELSIF 절을 사용하십시오. ELSE 절의 작업이 완전히 별개의 IF 문으로
구성된 경우에는 ELSIF 절을 사용하는 것이 편리합니다. ELSIF 절을 사용하면 추가된 각 조건 A I
및 작업의 끝에 END IF를 반복해서 사용하지 않아도 되므로 코드가 더욱 명확해집니다. O
예제
l &
IF condition1 THEN
statement1;
n a
statement2;
te r
I n
e
statement3;
END IF;
c l
ra
위의 IF-THEN-ELSIF 문 예제는 다음과 같이 정의됩니다.
값이 주어지면 원래 값의 백분율을 계산합니다. 값이 100보다 크면 계산된 값은 시작 값의
O
20%가 되고, 값이 50 이상 100 이하면 계산된 값은 시작 값의 50%가 되며, 입력된 값이 50보다
작으면 계산된 값은 시작 값의 10%가 됩니다.
참고: 널 값이 들어 있는 모든 산술식은 널로 평가됩니다.

CASE 표현식
y CASE 표현식은 결과를 선택하고 반환합니다.

y CASE 표현식은 결과를 선택할 때, 해당 값이 여러 조건
중 하나를 선택하는 데 사용되는 선택자(표현식)를
통해 선택합니다.
CASE selector
WHEN expression1 THEN result1
WHEN expression2 THEN result2
...
WHEN expressionN THEN resultN
[ELSE resultN+1;]
END;
n l y
e O
CASE 표현식
U s
CASE 표현식은 결과를 선택하고 반환합니다. CASE 표현식은 결과를 선택할 때, 해당 값이 여러
조건 중 하나를 선택하는 데 사용되는 선택자(표현식)를 통해 선택합니다. 선택자 뒤에는 하나
이상의 WHEN 절이 오고 여기에서 조건이 하나씩 검사됩니다. 실행될 절은 선택자의 값에 따라 A I
결정됩니다. 선택자의 값이 WHEN 절 표현식의 값과 동일하면 해당 WHEN 절이 실행됩니다. O
PL/SQL은 다음 형식을 가지는 검색된 CASE 표현식도 제공합니다.
l &
CASE
n a
te r
WHEN search_condition1 THEN result1
WHEN search_condition2 THEN result2
...
I n
WHEN search_conditionN THEN resultN
c le
[ELSE resultN+1;]
END;
/
r a
O
검색된 CASE 표현식에는 선택자가 없습니다. 또한 검색된 CASE 표현식의 WHEN 절에는 모든
유형의 값을 반환할 수 있는 표현식이 아니라 부울 값을 반환하는 검색 조건이 들어갑니다.

CASE 표현식: 예제
SET SERVEROUTPUT ON
DECLARE
v_grade CHAR(1) := UPPER('&p_grade');
v_appraisal VARCHAR2(20);
BEGIN
v_appraisal :=
CASE v_grade
WHEN 'A' THEN 'Excellent'
WHEN 'B' THEN 'Very Good'
WHEN 'C' THEN 'Good'
ELSE 'No such grade'
END;
DBMS_OUTPUT.PUT_LINE ('Grade: '|| v_grade || '
Appraisal ' || v_appraisal);
END;
/
n l y
e O
CASE 표현식: 예제
U s
슬라이드의 예제에서 CASE 표현식은 v_grade 변수의 값을 표현식으로 사용합니다. 이 값은
치환 변수를 통해 사용자의 입력을 받습니다. CASE 표현식은 사용자가 입력한 값을 받는
v_grade의 값에 기반하여 v_appraisal 변수의 값을 평가합니다. 위 예제의 출력 결과는 A I
다음과 같습니다. O
l &
n a
te r
I n
c le
ra
O

CASE 표현식: 예제(계속)
슬라이드의 예제를 검색된 CASE 표현식을 사용하여 작성하면 다음과 같습니다.
REM When prompted, supply p_grade = a in the code below.
DECLARE
v_grade CHAR(1) := UPPER('&p_grade');
v_appraisal VARCHAR2(20);
BEGIN
v_appraisal :=
CASE
WHEN v_grade = 'A' THEN 'Excellent'
WHEN v_grade = 'B' THEN 'Very Good'
WHEN v_grade = 'C' THEN 'Good'
ELSE 'No such grade'
END;
('Grade: '|| v_grade || ' Appraisal ' || v_appraisal);
END;
/
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O

Null 처리
널을 다룰 때 다음 규칙을 기억하면 일반적인 오류를 피할

수 있습니다.
• 널을 포함하는 단순 비교 결과는 항상 NULL입니다.
• 널에 논리 연산자 NOT을 적용하면 결과는 NULL이
됩니다.
• 조건 제어문에서 조건의 결과가 NULL이면 연관된
명령문 시퀀스가 실행되지 않습니다.
n l y
e O
Null 처리
U s
다음 예제에서 x와 y가 같지 않으므로 명령문 시퀀스가 실행될 것으로 예상하겠지만 값을 알 수
없는 NULL이 포함되었으므로 x와 y가 같은지 알 수 없습니다. 따라서 IF 조건의 결과는 NULL이
A I
되고 명령문 시퀀스는 무시됩니다.
x := 5; O
y := NULL;
l &
a
...
r n
IF x != y THEN -- yields NULL, not TRUE
sequence_of_statements; -- not executed
END IF;
I n te
다음 예제에서 a와 b가 같으므로 명령문 시퀀스가 실행될 것으로 예상하겠지만 a와 b가 같은지
알 수 없으므로 IF 조건의 결과는 NULL이 되고 명령문 시퀀스는 무시됩니다.
a := NULL;
c le
a
b := NULL;
...
O r
IF a = b THEN -- yields NULL, not TRUE
sequence_of_statements; -- not executed
END IF;

논리 테이블
비교 연산자를 사용하여 단순 부울 조건을 생성합니다.
AND TRUE FALSE NULL OR TRUE FALSE NULL NOT
TRUE TRUE FALSE NULL TRUE TRUE TRUE TRUE TRUE FALSE
FALSE FALSE FALSE FALSE FALSE TRUE FALSE NULL FALSE TRUE
NULL NULL FALSE NULL NULL TRUE NULL NULL NULL NULL
n l y
e O
논리 연산자를 사용한 부울 조건
U s
숫자, 문자 또는 날짜 표현식을 비교 연산자와 결합하여 단순 부울 조건을 생성할 수 있습니다.
단순 부울 조건을 논리 연산자인 AND, OR, NOT과 결합하여 복합 부울 조건을 생성할 수
A I
있습니다. 슬라이드의 논리 테이블을 통해 다음을 알 수 있습니다.
O
l &
y AND 조건에서는 FALSE의 우선순위가 높고 OR 조건에서는 TRUE의 우선순위가 높습니다.
y AND는 두 피연산자 모두가 TRUE일 경우에만 TRUE를 반환합니다.
n a
y OR는 두 피연산자 모두가 FALSE일 경우에만 FALSE를 반환합니다.
te r
y NULL AND TRUE은 두번째 피연산자가 TRUE로 평가될 것인지 아닌지 알 수 없기 때문에
항상 NULL로 평가됩니다.
I n
참고: 널 값은 알 수 없는 값이므로 NULL의 부정인 NOT NULL도 널 값을 반환합니다.
c l e
r a
O

부울 조건
각 경우에 대한 V_FLAG의 값은?
v_flag := v_reorder_flag AND v_available_flag;
V_REORDER_FLAG V_AVAILABLE_FLAG V_FLAG
TRUE TRUE ?
TRUE FALSE ?
NULL TRUE ?
NULL FALSE ?
n l y
e O
논리 조건 생성
U s
슬라이드의 AND 논리 테이블을 통해 부울 조건의 결과를 평가할 수 있습니다.
해답
A I
1. TRUE
O
2. FALSE
l &
3. NULL
n a
4. FALSE
te r
I n
c l e
r a
O

반복 제어: LOOP 문
y 루프는 명령문이나 명령문 시퀀스를 반복 실행합니다.

y 루프에는 세 가지 유형이 있습니다.
− 기본 루프
– FOR 루프
– WHILE 루프
n l y
e O
반복 제어: LOOP 문
U s
PL/SQL은 명령문이나 명령문 시퀀스를 반복 실행할 수 있도록 하기 위해 루프를 구조화할 수
있는 다양한 기능을 제공합니다.
A I
루프 생성자는 제어 구조의 두번째 유형입니다. PL/SQL에서는 다음과 같은 유형의 루프를
사용할 수 있습니다. O
y 기본 루프는 전체 조건 없이 반복 작업을 수행합니다.
l &
y FOR 루프는 횟수를 기준으로 작업의 반복을 제어합니다.
n a
te r
y WHILE 루프는 조건을 기준으로 작업의 반복을 제어합니다.
루프를 종료하려면 EXIT 문을 사용합니다.
I n
자세한 내용은 PL/SQL User's Guide and Reference, “Control Structures”를 참조하십시오.
le
참고: FOR LOOP의 또 다른 유형인 커서 FOR LOOP는 다음 단원에서 설명합니다.
c
r a
O

기본 루프
구문:
LOOP -- 구분자
statement1;
-- 명령문
. . .
EXIT [WHEN condition]; -- EXIT 문
END LOOP; -- 구문자
condition 부울 변수 또는 표현식입니다
(TRUE, FALSE, NULL).
n l y
e O
기본 루프
U s
LOOP 문의 가장 단순한 형태는 기본 루프 또는 무한 루프입니다. 기본 루프는 키워드 LOOP와
END LOOP 사이에 있는 명령문 시퀀스를 묶습니다. 실행 흐름이 END LOOP 문에 도달할 때마다
위에 있는 해당 LOOP 문으로 제어가 되돌아갑니다. 기본 루브에서는 루프를 시작할 때 이미 A I
조건이 만족되었더라도 해당 명령문을 적어도 한 번 이상 실행하며 EXIT 문이 없으면 루프가 O
끝없이 실행됩니다.
l &
EXIT 문
n a
te r
EXIT 문을 사용하여 루프를 종료할 수 있으며, 이 경우 제어는 END LOOP 문 다음에 있는
명령문으로 전달됩니다. EXIT는 IF 문 내의 작업 또는 루프 내의 독립적 명령문으로 실행할 수
있습니다. EXIT 문은 루프 내에 있어야 하며 루프에 WHEN 절을 첨부하여 루프를 조건에 따라
I n
종료할 수 있습니다. EXIT 문에 도달하면 WHEN 절의 조건이 평가됩니다. 조건의 결과가
c le
TRUE면 루프가 종료되며 제어는 루프 다음에 있는 명령문에 전달됩니다. 기본 루프는 여러 개의
EXIT 문을 포함할 수 있습니다.
ra
O

기본 루프
예제:
DECLARE
v_country_id locations.country_id%TYPE := 'CA';
v_location_id locations.location_id%TYPE;
v_counter NUMBER(2) := 1;
v_city locations.city%TYPE := 'Montreal';
BEGIN
SELECT MAX(location_id) INTO v_location_id FROM locations
WHERE country_id = v_country_id;
LOOP
INSERT INTO locations(location_id, city, country_id)
VALUES((v_location_id + v_counter),v_city, v_country_id);
v_counter := v_counter + 1;
EXIT WHEN v_counter > 3;
END LOOP;
END;
/
n l y
e O
기본 루프(계속)
U s
슬라이드의 기본 루프 예제는 국가 코드가 CA이고 도시 이름이 Montreal인 세 개의 새로운 위치
ID를 삽입합니다.
A I
참고: 기본 루프에서는 루프를 시작할 때 이미 조건이 만족되었더라도 조건이 루프 내에 있어서
명령문을 실행하지 않으면 조건이 검사되지 않는 경우 해당 명령문을 적어도 한 번 이상 O
l &
실행합니다. 그러나 종료 조건이 루프의 상단인 다른 실행문 앞에 있으며 조건이 TRUE면
루프가 종료되고 명령문이 실행되지 않습니다.
n a
te r
I n
c l e
r a
O

WHILE 루프
구문:
WHILE condition LOOP 반복이 시작될
statement1; 때마다 조건이
statement2; 평가됩니다.
. . .
END LOOP;
WHILE 루프를 사용하여 조건이 TRUE인 동안 명령문을

반복합니다.
n l y
e O
WHILE 루프
U s
WHILE 루프를 사용하여 제어 조건이 TRUE인 동안 명령문의 시퀀스를 반복할 수 있는데 반복이
시작될 때마다 조건이 평가됩니다. 조건이 FALSE면 루프가 종료되며, 루프를 시작할 때 조건이
FALSE면 반복 작업이 더 이상 실행되지 않습니다. A I
구문 설명: O
condition
l &
부울 변수 또는 표현식입니다(TRUE, FALSE, NULL).
statement
a
하나 이상의 PL/SQL 문 또는 SQL 문입니다.
n
루프가 종료되지 않습니다.
te r
조건에 포함된 변수가 루프 몸체(body) 내에서 변경되지 않으면 조건이 TRUE로 유지되므로
I n
참고: 조건의 결과가 NULL이면 제어는 루프를 건너뛰어 다음 명령문으로 전달됩니다.
c l e
r a
O

WHILE 루프
예제:
DECLARE
v_counter NUMBER := 1;
BEGIN
SELECT MAX(location_id) INTO v_location_id FROM locations
WHILE v_counter <= 3 LOOP
VALUES((v_location_id + v_counter), v_city, v_country_id);
v_counter := v_counter + 1;
END LOOP;
END;
/
n l y
e O
WHILE 루프(계속)
U s
슬라이드의 예제에서는 국가 코드가 CA이고 도시가 Montreal인 세 개의 새로운 위치 ID를
추가합니다.
A I
WHILE 루프를 한 번 반복할 때마다 카운터(v_counter)가 증가합니다. 반복 횟수가 3보다
작거나 같으면 루프 내의 코드가 실행되어 LOCATIONS 테이블에 행(row)을 삽입합니다. O
l &
카운터가 루프에 지정된 값을 넘어서면 루프를 제어하는 조건이 FALSE로 평가되어 루프가
종료됩니다.
n a
te r
I n
c l e
r a
O

FOR 루프
구문:
FOR counter IN [REVERSE]
lower_bound..upper_bound LOOP
statement1;
statement2;
. . .
END LOOP;
y FOR 루프를 사용하면 반복 횟수를 손쉽게 테스트할 수

있습니다.
y 카운터는 암시적으로(implicitly) 선언되므로 선언하지
마십시오.
y 'lower_bound .. upper_bound' 구문이 반드시
필요합니다.
n l y
e O
FOR 루프
U s
FOR 루프의 일반 구조는 기본 루프와 동일하며 LOOP 키워드 앞에 있는 제어문을 통해
PL/SQL이 수행할 반복 횟수를 결정합니다.
A I
counter 암시적으로 선언된 정수며 상한이나 하한에 도달할 때까지 루프가 반복될
O
때마다 값이 자동으로 1씩 증가 또는 감소(REVERSE 키워드를 사용하면 값이
감소)합니다.
l &
REVERSE
n a
상한에서 하한까지 반복할 때마다 카운터가 감소합니다. 이 경우에도 하한이
lower_bound
먼저 참조됩니다.
te r
카운터 값의 하한 범위를 지정합니다.
upper_bound
I n
카운터 값의 상한 범위를 지정합니다.
c le
카운터는 암시적으로(implicitly) 정수로 선언되므로 선언하지 마십시오.
참고: 명령문의 시퀀스는 카운터가 두 경계에 의해 판별되어 증가할 때마다 실행됩니다. 루프
r a
범위의 하한과 상한은 리터럴, 변수 또는 표현식이 될 수 있지만 반드시 정수로 평가되어야
합니다. 하한과 상한은 루프 범위에 포함됩니다. REVERSE를 사용하지 않은 경우 루프 범위의
O
하한이 상한보다 큰 정수로 평가되면 명령문 시퀀스는 실행되지 않습니다. 다음 예제의 경우
명령문은 한 번만 실행됩니다.
FOR i IN 3..3 LOOP statement1; END LOOP;

FOR 루프
국가 코드가 CA이고 도시 이름이 Montreal인 세 개의 새로운

위치 ID를 삽입합니다.
DECLARE
BEGIN
SELECT MAX(location_id) INTO v_location_id
FROM locations
FOR i IN 1..3 LOOP
VALUES((v_location_id + i), v_city, v_country_id );
END LOOP;
END;
y
/
n l
e O
FOR 루프(계속)
U s
슬라이드의 예제는 국가 코드가 CA이고 도시 이름이 Montreal인 세 개의 새로운 위치 ID를
삽입합니다.
A I
이 작업은 FOR 루프를 사용해 수행합니다.
O
l &
n a
te r
I n
c le
r a
O

FOR 루프
지침
y 카운터는 루프 내에서만 참조할 수 있으며 루프 밖에서는
정의되지 않습니다.
y 카운터를 할당 대상으로 참조하지 마십시오.
FOR 루프(계속)
슬라이드의 내용은 FOR 루프를 작성할 때 따라야 할 지침입니다.
참고: FOR 루프를 작성할 때 LOOP 문의 상한 및 하한은 숫자 리터럴이 아니어도 됩니다.
숫자 값으로 변환되는 표현식을 사용해도 됩니다.
예제
DECLARE
v_lower NUMBER := 1;
v_upper NUMBER := 100;
BEGIN
FOR i IN v_lower..v_upper LOOP
...
END LOOP;
END;

루프 사용 지침
y 루프 내의 명령문을 적어도 한 번은 실행해야 한다면

기본 루프를 사용합니다.
y 반복할 때마다 조건을 평가해야 한다면 WHILE 루프를
사용합니다.
y 반복 횟수를 알고 있다면 FOR 루프를 사용합니다.
n l y
e O
루프 사용 지침
U s
기본 루프에서는 루프를 시작할 때 조건이 이미 만족되었더라도 해당 명령문을 적어도 한 번
이상 실행합니다. EXIT 문이 없으면 루프는 무한 루프가 됩니다.
A I
WHILE 루프를 사용하면 제어 조건이 TRUE인 동안 명령문의 시퀀스를 반복할 수 있는데, 이
조건은 반복이 시작될 때마다 평가됩니다. 조건이 FALSE면 루프가 종료되며, 루프를 시작할 때 O
조건이 FALSE면 더 이상 반복되지 않습니다.
l &
a
FOR 루프의 LOOP 키워드 앞에는 제어문이 있어서 PL/SQL이 수행하는 반복 횟수를 결정합니다.
n
r
반복 횟수가 미리 결정되어 있다면 FOR 루프를 사용하십시오.
te
I n
c le
ra
O

중첩 루프와 레이블
y 루프는 여러 레벨로 중첩할 수 있습니다.

y 레이블을 사용하여 블록과 루프를 구분합니다.
y 레이블을 참조하는 EXIT 문을 사용하여 외부 루프를
종료합니다.
n l y
e O
U s
루프는 여러 레벨로 중첩할 수 있습니다. FOR 루프, WHILE 루프 및 기본 루프는 서로 중첩할 수
있습니다. 내부 루프가 종료되어도 예외가 발생하지 않으면 외부 루프는 종료되지 않습니다.
그러나 루프에 레이블을 지정하고 EXIT 문을 사용하여 외부 루프를 종료할 수 있습니다. A I
레이블 이름은 다른 식별자와 동일한 규칙을 따릅니다. 레이블은 명령문 앞에 놓이며 명령문과 O
l &
동일한 행 또는 다른 행으로 지정할 수 있습니다. 루프의 레이블을 지정할 때는 LOOP라는 단어
a
앞에 레이블 이름을 붙이고 앞뒤로 레이블 구분자(<<label>>)를 붙입니다.
n
있습니다(선택사항).
te r
루프에 레이블을 지정할 경우 END LOOP 문 다음에 레이블 이름을 포함시켜 명확하게 할 수도
I n
c le
ra
O

...
BEGIN
<<Outer_loop>>
LOOP
v_counter := v_counter+1;
EXIT WHEN v_counter>10;
<<Inner_loop>>
LOOP
...
EXIT Outer_loop WHEN total_done = 'YES';
-- Leave both loops
EXIT WHEN inner_done = 'YES';
-- Leave inner loop only
...
END LOOP Inner_loop;
...
END LOOP Outer_loop;
END;
n l y
e O
중첩 루프와 레이블(계속)
U s
슬라이드 예제에는 두개의 루프가 있는데 외부 루프에는 <<Outer_Loop>> 레이블이, 내부
루프에는 <<Inner_Loop>> 레이블이 지정되어 있습니다. LOOP라는 단어 앞에 식별자를
A I
O
붙이고 앞뒤에 레이블 구분자(<<label>>)를 붙여 레이블을 지정했습니다. 내부 루프가 외부 루프
내에 중첩되어 있고 END LOOP 문 다음에 레이블 이름을 지정하여 코드를 명확하게
하였습니다.
l &
n a
te r
I n
c le
ra
O

요약

제어 구조를 사용하여 명령문의 논리적 흐름 변경
• 조건(IF 문)
• CASE 표현식
• 루프:
– 기본 루프
– FOR 루프
– WHILE 루프
y EXIT 문
n l y
e O
요약
U s
조건 제어 생성자는 조건의 유효성을 확인하고 그에 해당되는 작업을 수행합니다.
IF 생성자를 사용하면 명령문을 조건에 따라 실행할 수 있습니다.
A I
반복 제어 생성자는 지정된 조건이 TRUE인 동안 명령문의 시퀀스를 반복 실행합니다.
다양한 루프 생성자를 사용하여 반복 작업을 수행할 수 있습니다. O
l &
n a
te r
I n
c le
ra
O

연습 4 개요

y IF 문을 사용한 조건별 작업 수행
y 루프 구조를 사용한 반복 단계 수행
n l y
e O
연습 4 개요
U s
이 연습에서는 루프와 조건 제어 구조가 포함된 PL/SQL 블록을 작성합니다. 이를 통해 다양한
IF 문과 LOOP 생성자의 작성에 대한 이해도를 테스트합니다.
A I
O
l &
n a
te r
I n
c le
ra
O

연습 4
1. lab04_1.sql 파일의 명령을 실행하여 MESSAGES 테이블을 생성한 후 MESSAGES
테이블에 번호를 삽입하는 PL/SQL 블록을 작성하십시오.
a. 6과 8은 제외하고 1에서 10까지 삽입하십시오.
b. 블록을 끝내기 전에 커밋하십시오.
c. MESSAGES 테이블에 대해 SELECT 명령을 실행하여 PL/SQL 블록이 작동하는지
확인하십시오.
2. 사원 급여를 기준으로 지정한 사원의 상여금을 계산하는 PL/SQL 블록을 작성하십시오.

n l y
a. DEFINE 명령을 사용하여 사원 ID를 지정하고 값을 iSQL*Plus 치환 변수를 통해
PL/SQL 블록으로 전달하십시오.
e O
DEFINE p_empno = 100
b. 사원의 급여가 $5,000보다 적은 경우 급여의 10%를 그 사원의 상여금으로
U s
표시하십시오.
A I
c. 사원의 급여가 $5,000 이상 $10,000 이하인 경우 급여의 15%를 그 사원의
상여금으로 표시하십시오. O
l &
d. 사원의 급여가 $10,000보다 많으면 급여의 20%를 그 사원의 상여금으로
표시하십시오.
n a
te r
e. 사원의 급여가 NULL인 경우 그 사원의 상여금을 0으로 설정하십시오.
f. 다음 테스트 사례를 사용하여 각 사례에 대해 PL/SQL 블록을 테스트하고
I n
각 상여금을 확인하십시오.
참고: 해답에 SET VERIFY OFF를 지정하십시오.
c l e
r a
O
사원 번호 급여 계산된 상여금
100 24000 4800
149 10500 2100
178 7000 1050

연습 4(계속)
3. lab04_3.sql 스크립트를 실행하여 EMPLOYEES 테이블과 동일한 EMP 테이블을 생성한
다음 EMP 테이블에 별표(*)를 저장하기 위한 새 열을 작성하십시오. 이 열의 이름은
STARS, 데이터 유형은 VARCHAR2, 길이는 50으로 지정하십시오.
4. 사원의 급여 $1000마다 STARS 열에 별표를 하나씩 추가하여 사원의 급여를 평가하는

PL/SQL 블록을 작성하십시오. 그런 다음 Save Script 버튼을 눌러 PL/SQL 블록을
p4q4.sql이라는 이름의 파일로 저장하십시오. 스크립트는 .sql 확장자로 저장해야
합니다.
a. DEFINE 명령을 사용하여 사원 ID를 지정하고 값을 iSQL*Plus 치환 변수를 통해
DEFINE p_empno=104
b. NULL을 포함하는 v_asterisk 변수를 초기화하십시오.
c. 급여 $1000마다 문자열에 별표를 추가하십시오. 예를 들어, 사원의 급여가 $8000면
별표 문자열에 8개의 별표가 포함되어야 하고 $12500면 별표 문자열에 13개의
별표가 포함되어야 합니다.
d. 사원의 STARS 열을 별표 문자열로 갱신하십시오.
e. 커밋하십시오.
f. 다음의 값으로 블록을 테스트하십시오. n l y
DEFINE p_empno=174
DEFINE p_empno=176
e O
g. EMP 테이블의 행(row)을 표시하여 PL/SQL 블록이 올바르게 실행되었는지
확인하십시오.
U s
A I
O
l &
n a
te r
n
참고: PL/SQL 블록에 SET VERIFY OFF를 지정하십시오.
I
c l e
r a
O

조합 데이터 유형 사용
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 사용자가 정의한 PL/SQL 레코드 생성
y %ROWTYPE 속성을 사용하여 레코드 생성
y INDEX BY 테이블 생성
y 레코드의 INDEX BY 테이블 생성
y 레코드, 테이블, 레코드 테이블 간의 차이 설명
n l y
e O
단원 목표
U s
이 단원에서는 조합 데이터 유형과 그 사용 방법에 대해 설명합니다.
A I
O
l &
n a
te r
I n
c le
ra
O

y 다음 두 가지 유형이 있습니다.
− PL/SQL RECORD
− PL/SQL Collection
– INDEX BY 테이블
– Nested Table
– VARRAY
y 내부 구성 요소를 포함합니다.
y 재사용 가능합니다.
n l y
e O
RECORD 데이터 유형과 TABLE 데이터 유형
U s
스칼라 변수와 같이 조합 변수에도 데이터 유형이 있습니다. 조합 데이터
A I
유형(collection이라고도 함)에는 RECORD, TABLE, NESTED TABLE과 VARRAY가 있습니다.
RECORD 데이터 유형은 서로 관련되어 있지만 각기 다른 데이터를 하나의 논리 단위로 처리할
때 사용하고, TABLE 데이터 유형은 데이터 collection을 전체 객체로 참조하여 조작할 때 O
&
사용합니다. NESTED TABLE과 VARRAY 데이터 유형은 Advanced PL/SQL 과정에서 설명합니다.
l
n a
레코드는 필드에 저장된 관련 데이터 항목의 그룹으로, 레코드마다 고유한 이름과 데이터
유형을 가집니다. 테이블에는 열과 기본 키가 있어서 행(row)을 배열 형태로 액세스할 수
te r
있습니다. 정의된 테이블 및 레코드는 재사용할 수 있습니다.
자세한 내용은 PL/SQL User's Guide and Reference, “Collections and Records”를 참조하십시오.
I n
c l e
ra
O

PL/SQL 레코드
y 스칼라, RECORD 또는 INDEX BY 테이블 데이터 유형의

구성 요소(필드)를 하나 이상 포함해야 합니다.
y 3GL(3세대 언어)의 레코드 구조와 유사합니다.
y 데이터베이스 테이블의 행(row)과 동일하지 않습니다.
y 필드 collection을 하나의 논리적 단위로 처리합니다.
y 테이블에서 데이터 행(row)을 인출(fetch)하여 처리하는
데 편리합니다.
n l y
e O
PL/SQL 레코드
U s
레코드는 필드에 저장된 관련 데이터 항목의 그룹으로, 레코드마다 고유한 이름과 데이터
유형을 가집니다. 예를 들어, 이름, 급여, 입사일 등과 같은 사원에 관한 서로 다른 종류의
A I
데이터가 있다고 가정합니다. 이러한 데이터는 유형은 서로 다르지만 논리적으로 연관되어
있습니다. 사원의 이름, 급여, 입사일 등과 같은 필드가 들어있는 레코드가 있으면 데이터를 O
하나의 단위로 처리할 수 있습니다.
l &
하나의 논리적 단위로 처리할 수 있습니다. 이러한 필드에 레코드 유형을 선언하면 해당 필드를
n a
y 정의된 각 레코드는 필드를 필요한 만큼 포함할 수 있습니다.
te r
y 레코드에는 초기값을 할당하고 NOT NULL로 정의할 수 있습니다.
I n
y 초기값이 없는 필드는 NULL로 초기화됩니다.
y 필드를 정의할 때 DEFAULT 키워드를 사용할 수 있습니다.
le
y RECORD 유형을 정의하고 사용자 정의 레코드를 블록, 서브 프로그램 또는 패키지의 선언
c
r a
부분에서 선언할 수 있습니다.
y 중첩 레코드를 선언하고 참조할 수 있습니다. 레코드는 다른 레코드의 구성 요소가 될 수
O 있습니다.

PL/SQL 레코드 생성
구문:
TYPE type_name IS RECORD
(field_declaration[, field_declaration]…);
identifier type_name;
여기서 field_declaration은 다음과 같습니다.

field_name {field_type | variable%TYPE
| table.column%TYPE | table%ROWTYPE}
[[NOT NULL] {:= | DEFAULT} expr]
n l y
e O
PL/SQL 레코드 정의 및 선언
U s
레코드를 생성하려면 RECORD 유형을 정의한 후 해당 유형의 레코드를 선언합니다.
구문 설명:
A I
type_name
O
RECORD 유형의 이름이며 레코드를 선언할 때 이 식별자를
사용합니다.
field_name 레코드의 필드 이름입니다.
l &
field_type
n a
필드의 데이터 유형이며 REF CURSOR를 제외한 모든 PL/SQL
수 있습니다.
te r
데이터 유형을 나타냅니다. %TYPE과 %ROWTYPE 속성을 사용할
expr
I n field_type 또는 초기값입니다.
l e
NOT NULL 제약 조건이 있는 필드에는 널을 할당할 수 없으므로 NOT NULL 필드는 반드시
초기화해야 합니다.
c
r a
O

신입 사원의 이름, 업무, 급여를 저장할 변수를 선언합니다.
예제:
...
TYPE emp_record_type IS RECORD
(last_name VARCHAR2(25),
job_id VARCHAR2(10),
salary NUMBER(8,2));
emp_record emp_record_type;
...
n l y
e O
U s
필드 선언은 변수 선언과 유사합니다. 각 필드는 고유한 이름과 특정 데이터 유형을 가집니다.
스칼라 변수에는 미리 정의된 데이터 유형이 있지만 PL/SQL 레코드에는 미리 정의된 데이터
A I
유형이 없으므로 먼저 레코드 유형을 생성한 후 해당 유형을 사용하여 식별자를 선언해야
합니다. O
l &
슬라이드의 예제에서는 last_name, job_id, salary의 값을 보유할 EMP_RECORD_TYPE
레코드를 선언합니다.
n a
레코드 유형을 정의합니다. 다음 단계에서는 EMP_RECORD_TYPE 유형의 EMP_RECORD
te r
다음은 %TYPE 속성을 사용하여 필드의 데이터 유형을 지정하는 예제입니다.
DECLARE
I n
e
TYPE emp_record_type IS RECORD
cl
(employee_id NUMBER(6) NOT NULL := 100,
O ra last_name
job_id
emp_record
employees.last_name%TYPE,
employees.job_id%TYPE);
emp_record_type;
...
참고: 필드 선언에 NOT NULL 제약 조건을 추가하여 해당 필드에 널을 할당하지 못하도록 할 수
있습니다. NOT NULL로 선언한 필드는 반드시 초기화해야 합니다.

PL/SQL 레코드 구조
Field1 (데이터 유형) Field2 (데이터 유형) Field3 (데이터 유형)
예제:
Field1 (데이터 유형) Field2 (데이터 유형) Field3 (데이터 유형)

employee_id number(6) last_name varchar2(25) job_id varchar2(10)
100 King AD_PRES
n l y
e O
PL/SQL 레코드 구조
U s
레코드의 필드는 이름을 사용하여 액세스합니다. 개별 필드를 참조하거나 초기화할 때는 점
표기법과 다음 구문을 사용합니다.
A I
record_name.field_name
O
emp_record.job_id ...
l &
예를 들어 emp_record 레코드의 job_id 필드를 참조하려면 다음과 같은 구문을 사용합니다.
n
그런 다음 아래와 같이 지정하여 레코드 필드에 값을 할당할 수 있습니다. a
te r
emp_record.job_id := 'ST_CLERK';
I
인스턴스화되고, 종료하면 없어집니다.n
블록 또는 서브 프로그램에서 사용자 정의 레코드는 블록 또는 서브 프로그램을 시작하면
c l e
r a
O

%ROWTYPE 속성
y 데이터베이스 테이블 또는 뷰의 열 collection에 따라

변수를 선언합니다.
y %ROWTYPE에 데이터베이스 테이블 이름을 접두어로
붙입니다.
y 레코드 필드의 이름과 데이터 유형을 테이블 또는 뷰의
열에서 가져옵니다.
n l y
e O
%ROWTYPE 속성을 사용하여 레코드 선언
데이터베이스 테이블 또는 뷰의 열 collection에 따라 레코드를 선언하려면 %ROWTYPE 속성을
U s
사용합니다. 레코드 필드의 이름과 데이터 유형은 테이블 또는 뷰의 열에서 가져옵니다.
레코드에는 커서 또는 커서 변수에서 인출(fetch)한 전체 데이터 행(row)도 저장할 수 있습니다.
A I
다음 예제에서는 %ROWTYPE을 데이터 유형 지정자로 사용하여 레코드를 선언합니다.
O
DECLARE
l &
emp_record
... a
employees%ROWTYPE;
n
te r
emp_record 레코드의 구조는 다음 필드로 구성되며 각 필드는 EMPLOYEES 테이블의 열을
나타냅니다.
I n
참고: 다음은 코드가 아니라 조합 변수의 구조입니다.
c l
first_namee
(employee_id NUMBER(6),
VARCHAR2(20),
r
emaila
last_name VARCHAR2(20),
VARCHAR2(20),
O
phone_number
hire_date
salary
VARCHAR2(20),
DATE,
NUMBER(8,2),
commission_pct NUMBER(2,2),
manager_id NUMBER(6),
department_id NUMBER(4))

%ROWTYPE 속성을 사용하여 레코드 선언(계속)
구문
DECLARE
identifier reference%ROWTYPE;
설명: identifier 레코드 전체를 식별하기 위해 선택한 이름입니다.
reference 레코드가 기반을 두고 있는 테이블, 뷰, 커서 또는 커서 변수의
이름입니다. 해당 테이블이나 뷰가 존재해야 이 참조가
유효합니다.
개별 필드를 참조하려면 점 표기법과 다음 구문을 사용하십시오.
record_name.field_name
예를 들어 emp_record 레코드의 commission_pct 필드를 참조하려면 다음 구문을
사용합니다.
emp_record.commission_pct
그런 다음 아래와 같이 지정하여 레코드 필드에 값을 할당할 수 있습니다.
emp_record.commission_pct:= .35;
레코드에 값 할당
SELECT 또는 FETCH 문을 사용하여 레코드에 값 목록을 할당할 수 있습니다. 이때 열 이름은
레코드의 필드와 동일한 순서로 표시해야 하며 데이터 유형이 동일하면 레코드를 다른
레코드에 할당할 수도 있습니다. 사용자 정의 레코드와 %ROWTYPE 레코드의 데이터 유형은
전혀 다릅니다.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O

%ROWTYPE 사용의 장점
y 기본 데이터베이스 열의 수나 데이터 유형을 몰라도

사용할 수 있습니다.
y 실행 중에 기본 데이터베이스 열의 수나 데이터 유형을
변경할 수 있습니다.
y SELECT * 문을 사용하여 행(row)을 검색할 때
유용합니다.
n l y
e O
%ROWTYPE 사용의 장점
U s
슬라이드의 내용은 %ROWTYPE 속성의 장점을 요약한 것입니다. 기본 데이터베이스 테이블의
구조를 잘 모른다면 %ROWTYPE 속성을 사용하십시오. 이 속성을 사용하여 선언한 변수의
A I
데이터 유형은 기본 테이블이 바뀌면 동적으로 변경됩니다. 이 속성은 테이블에서 행(row)
O
전체를 검색할 때 특히 유용합니다. 이 속성이 없다면 SELECT * 문으로 검색한 모든 열 각각에
변수를 선언해야 합니다.
l &
n a
te r
I n
c le
ra
O

%ROWTYPE 속성
예제:
DEPARTMENTS 테이블의 부서 정보를 저장할 변수를
선언합니다.
dept_record departments%ROWTYPE;
EMPLOYEES 테이블의 사원 정보를 저장할 변수를

선언합니다.
emp_record employees%ROWTYPE;
n l y
e O
%ROWTYPE 속성
U s
슬라이드의 첫번째 선언에서는 필드 이름과 필드 데이터 유형이 DEPARTMENTS 테이블의
행(row)과 동일한 레코드를 생성합니다. 이 필드는 각각 DEPARTMENT_ID,
A
DEPARTMENT_NAME, MANAGER_ID, LOCATION_ID입니다. 두번째 선언에서는 필드 이름, 필드
I
데이터 유형 및 순서가 EMPLOYEES 테이블의 행(row)과 동일한 레코드를 생성합니다. 이 필드는O
&
각각 EMPLOYEE_ID, FIRST_NAME, LAST_NAME, EMAIL, PHONE_NUMBER, HIRE_DATE,
l
a
JOB_ID, SALARY, COMMISSION_PCT, MANAGER_ID, DEPARTMENT_ID입니다.
r n
I n te
c le
ra
O

%ROWTYPE 속성(계속)
다음 예제는 사원이 퇴사한 경우입니다. 퇴사한 사원에 대한 정보는 퇴사한 사원에 대한 정보를
보유하는 테이블에 추가됩니다. 사용자가 퇴사한 사원의 사원 번호를 제공하면, 지정한 사원의
레코드를 EMPLOYEES에서 검색한 후 %ROWTYPE 속성을 사용해 선언한 변수인 emp_rec에
저장합니다.
DEFINE employee_number = 124
DECLARE
emp_rec employees%ROWTYPE;
BEGIN
SELECT * INTO emp_rec
FROM employees
WHERE employee_id = &employee_number;
INSERT INTO retired_emps(empno, ename, job, mgr, hiredate,
leavedate, sal, comm, deptno)
VALUES (emp_rec.employee_id, emp_rec.last_name, emp_rec.job_id,
emp_rec.manager_id, emp_rec.hire_date, SYSDATE, emp_rec.salary,
emp_rec.commission_pct, emp_rec.department_id);
COMMIT;
END;
n l y
/
e O
다음은 RETIRED_EMPS 테이블에 삽입된 레코드입니다.
U s
SELECT * FROM RETIRED_EMPS;
A I
O
l &
n a
te r
I n
c l e
r a
O

INDEX BY 테이블
y 다음 두 개의 구성 요소로 구성됩니다.
− BINARY_INTEGER 데이터 유형의 기본 키
− 스칼라 또는 레코드 데이터 유형의 열
y 크기 제한이 없으므로 동적으로 증가할 수 있습니다.
n l y
e O
INDEX BY 테이블
U s
TABLE 유형의 객체를 INDEX BY 테이블이라고 하며 데이터베이스 테이블과 유사한 방식으로
모델링됩니다(데이터베이스 테이블과 동일하지는 않음). INDEX BY 테이블에서는 기본 키를
A I
사용하여 배열과 같은 방식으로 행(row)에 액세스할 수 있습니다.
INDEX BY 테이블: O
y 배열과 유사합니다.
l &
y 다음 두 개의 구성 요소를 포함해야 합니다.
n a
te r
− INDEX BY 테이블을 인덱스화하는 BINARY_INTEGER 데이터 유형의 기본 키
− INDEX BY 테이블 요소를 저장하는 스칼라 또는 레코드 데이터 유형의 열
I n
y 크기 제한이 없으므로 동적으로 증가할 수 있습니다.
c l e
r a
O

INDEX BY 테이블 생성
구문:
TYPE type_name IS TABLE OF
{column_type | variable%TYPE
| table.column%TYPE} [NOT NULL]
| table.%ROWTYPE
[INDEX BY BINARY_INTEGER];
identifier type_name;
이름을 저장할 INDEX BY 테이블을 선언합니다.

예제:
...
TYPE ename_table_type IS TABLE OF
employees.last_name%TYPE
INDEX BY BINARY_INTEGER;
ename_table ename_table_type;
...
n l y
e O
U s
INDEX BY 테이블 생성은 다음 두 단계로 이루어집니다.
1. TABLE 데이터 유형을 선언합니다.
A I
2. 해당 데이터 유형의 변수를 선언합니다.
O
구문 설명:
l &
type_name
a
TABLE 유형의 이름으로, 이후의 PL/SQL 테이블 선언에 사용되는
n
유형 지정자입니다.
te r
column_type
n
VARCHAR2, DATE, NUMBER 또는%TYPE과 같은 모든
I
스칼라(스칼라 및 조합) 데이터 유형입니다. %TYPE 속성을
c le
사용하여 열 데이터 유형을 지정할 수 있습니다.
identifier
r a
NOT NULL 제약 전체
조건을PL/SQL
사용하면 테이블을 나타내는
해당 유형의 식별자의
PL/ SQL 테이블에이름입니다.
널을 할당할 수 없습니다.
O
INDEX BY 테이블은 초기화하지 마십시오.
INDEX-BY 테이블에는 BINARY_INTEGER, BOOLEAN, LONG, LONG RAW, NATURAL,
NATURALN, PLS_INTEGER, POSITIVE, POSITIVEN, SIGNTYPE 및 STRING과 같은 유형의
요소를 사용할 수 있습니다. INDEX-BY 테이블은 처음에는 조밀하지 않은 상태이기 때문에
숫자 기본 키를 인덱스로 사용하여 INDEX-BY 테이블에 참조 데이터를 저장하는 등의 작업이
가능합니다.

INDEX BY 테이블 구조
고유 식별자 열
... ...
1 Jones
2 Smith
3 Maduro
... ...
BINARY_INTEGER 스칼라
n l y
e O
INDEX BY 테이블 구조
U s
데이터베이스 테이블과 마찬가지로 INDEX BY 테이블도 크기 제한이 없습니다. 즉 새
행(row)이 추가되면 INDEX BY 테이블이 커질 수 있도록 INDEX BY 테이블의 행(row) 수는
A I
동적으로 증가할 수 있습니다.
INDEX BY 테이블에는 하나의 열과 이 열에 대한 고유 식별자가 있을 수 있으며 두 가지 모두O
l &
이름을 지정할 수 없습니다. 열은 스칼라 또는 레코드 데이터 유형에 속할 수 있지만 기본 키는
n a
BINARY_INTEGER 유형에 속해야 합니다. INDEX BY 테이블은 선언할 때 초기화할 수
없습니다. 즉 테이블을 선언할 때 채워지지 않으며 키나 값을 포함하지 않습니다. INDEX BY
r
테이블을 초기화하려면, 즉 채우려면 명시적(explicit) 실행문을 사용해야 합니다.
te
I n
c le
ra
O

DECLARE
TYPE ename_table_type IS TABLE OF
employees.last_name%TYPE
TYPE hiredate_table_type IS TABLE OF DATE
ename_table ename_table_type;
hiredate_table hiredate_table_type;
BEGIN
ename_table(1) := 'CAMERON';
hiredate_table(8) := SYSDATE + 7;
IF ename_table.EXISTS(1) THEN
INSERT INTO ...
...
END;
/
n l y
e O
INDEX BY 테이블 참조
U s
구문:
INDEX_BY_table_name(primary_key_value)
A I
설명: primary_key_value
O
BINARY_INTEGER 유형에 속합니다.
INDEX BY 테이블인 ENAME_TABLE의 세번째 행(row)을 참조합니다.
l &
ename_table(3) ...
n a
있습니다. 인덱스는 1부터 시작되지 않아도 됩니다.
te r
BINARY_INTEGER의 크기 범위는 -2147483647...2147483647이므로 기본 키 값이 음수가 될 수
I n
참고: table.EXISTS(i)문은 인덱스가 i인 행(row)이 반환되면 TRUE를 반환합니다. 존재하지
않는 테이블 요소를 참조할 때 발생하는 오류를 방지하려면 EXISTS 문을 사용하십시오.
c l e
ra
O

INDEX BY 테이블 메소드 사용
다음 메소드를 사용하면 PL/SQL 테이블을 쉽게 사용할

수 있습니다.
– EXISTS – NEXT
– COUNT – TRIM
– FIRST 및 LAST – DELETE
– PRIOR
n l y
e O
INDEX BY 테이블 메소드 사용
U s
INDEX BY 테이블 메소드는 테이블에서 실행되며 점 표기법을 통해 호출되는 내장 프로시저
또는 함수입니다.
A I
구문: table_name.method_name[ (parameters) ]
O
메소드 설명
l &
EXISTS(n)
n a
PL/SQL 테이블에 n번째 요소가 존재하면 TRUE를 반환합니다.
COUNT
FIRST
te r
현재 PL/SQL 테이블에 있는 요소 수를 반환합니다.
PL/SQL 테이블의 첫번째와 마지막 인덱스 번호(가장 작은 번호와 가
LAST
I n
장 큰 번호)를 반환합니다. PL/SQL 테이블이 비어 있으면 NULL을 반
PRIOR(n)
c le 환합니다.
PL/SQL 테이블에서 인덱스 n 앞의 인덱스 번호를 반환합니다.
NEXT(n)
r a PL/SQL 테이블에서 인덱스 n 다음의 인덱스 번호를 반환합니다.
TRIM
O TRIM은 PL/SQL 테이블의 끝에서 요소를 하나 제거합니다.
TRIM(n)은 PL/SQL 테이블의 끝에서 요소를 n개 제거합니다.
DELETE DELETE는 PL/SQL 테이블에서 모든 요소를 제거합니다.
DELETE(n)은 PL/SQL 테이블에서 n번째 요소를 제거합니다.
DELETE(m, n)은 PL/SQL 테이블에서 범위 m ... n에 있는 모든 요소
를 제거합니다.

레코드의 INDEX BY 테이블
• 허용된 PL/SQL 데이터 유형을 사용하여 TABLE 변수를

정의합니다.
• 부서 정보를 보유할 PL/SQL 변수를 선언합니다.
예제:
DECLARE
TYPE dept_table_type IS TABLE OF
departments%ROWTYPE
dept_table dept_table_type;
-- Each element of dept_table is a record
n l y
e O
레코드의 INDEX BY 테이블
U s
일정 시점에서 INDEX BY 테이블은 데이터베이스 테이블의 열 중 하나의 세부 사항만 저장할
수 있지만, 질의에 의해 검색된 모든 열을 저장해야 하는 경우가 많습니다. 이런 경우 레코드의
INDEX BY 테이블이 해결책을 제시합니다. 레코드 테이블을 사용하는 경우, 하나의 테이블 A I
정의만 있으면 데이터베이스 테이블의 모든 필드에 대한 정보를 저장할 수 있으므로 INDEX BY O
테이블의 기능이 크게 향상됩니다.
l &
레코드 테이블 참조
n a
수 있습니다.
te r
슬라이드 예제에서는 테이블의 각 요소가 레코드이므로 DEPT_TABLE 레코드의 필드를 참조할
구문:
I n
e
table(index).field
예제:
c l
r a
dept_table(15).location_id := 1700;
O
LOCATION_ID는 DEPT_TABLE의 필드를 나타냅니다.
참고: %ROWTYPE 속성을 사용하여 데이터베이스 테이블의 행(row)을 나타내는 레코드를 선언할
수 있습니다. 조합 데이터 유형인 RECORD를 사용하면 레코드 필드의 데이터 유형을 지정하거나
사용자 고유의 필드를 선언할 수 있는데 %ROWTYPE 속성에는 이러한 기능이 없습니다.

레코드의 INDEX BY 테이블 예제
SET SERVEROUTPUT ON
DECLARE
TYPE emp_table_type is table of
employees%ROWTYPE INDEX BY BINARY_INTEGER;
my_emp_table emp_table_type;
v_count NUMBER(3):= 104;
BEGIN
FOR i IN 100..v_count
LOOP
SELECT * INTO my_emp_table(i) FROM employees
WHERE employee_id = i;
END LOOP;
FOR i IN my_emp_table.FIRST..my_emp_table.LAST
LOOP
DBMS_OUTPUT.PUT_LINE(my_emp_table(i).last_name);
END LOOP;
END;
n l y
e O
레코드의 INDEX BY 테이블 예제
U s
슬라이드의 예제에서는 EMPLOYEE_ID가 100에서 104 사이에 속한 사원의 세부 정보를 임시
저장할, 레코드의 INDEX BY 테이블인 emp_table_type을 선언합니다. 루프를 사용하여
EMPLOYEES 테이블의 사원 정보를 검색하여 INDEX BY 테이블에 저장합니다. 또 다른 루프를 A I
사용하여 INDEX BY 테이블에 있는 성(last name)에 관한 정보를 출력합니다. 예제에서 O
FIRST와 LAST 메소드의 사용을 눈여겨보십시오.
l &
n a
te r
I n
c le
r a
O

요약

y 조합 데이터 유형의 PL/SQL 변수를 정의 및
참조합니다.
− PL/SQL 레코드
– INDEX BY 테이블
– 레코드의 INDEX BY 테이블
y %ROWTYPE 속성을 사용하여 PL/SQL 레코드를
정의합니다.
n l y
e O
요약
U s
PL/SQL 레코드는 테이블의 행(row)을 나타내는 개별적인 필드들의 collection입니다. 레코드를
사용하면 데이터를 하나의 구조로 그룹화한 다음 이 구조를 하나의 엔티티 즉, 하나의 논리적
A I
단위로 조작할 수 있으므로, 코딩 작업이 줄어들고 코드를 이해하고 유지 관리하기가 쉽습니다.
PL/SQL 레코드와 마찬가지로 테이블도 하나의 조합 데이터 유형입니다. INDEX BY 테이블은 O
l &
TABLE 유형의 객체며 데이터베이스 테이블과 유사하게 보이지만 약간 다릅니다. 사용자는
n a
INDEX BY 테이블의 기본 키를 사용하여 행(row)을 배열 형태로 액세스할 수 있습니다. INDEX
BY 테이블의 크기에 대한 제한은 없습니다. INDEX BY 테이블에는 하나의 열과 기본 키가
BINARY_INTEGER 유형이어야 합니다.

te r
있는데 이에 대한 이름은 지정할 수 없습니다. 열은 모든 데이터 유형을 가질 수 있지만 기본 키는
I n
레코드의 INDEX BY 테이블에서는 모든 필드에 관한 정보를 보유하는 데 하나의 테이블 정의만
c l e
필요하므로 PL/SQL 테이블의 기능을 크게 향상시킵니다.
다음 collection 메소드를 사용하면 코드를 일반화할 수 있고, collection을 쉽게 사용할 수 있으며,
ra
응용 프로그램을 쉽게 유지 관리할 수 있습니다.
O
EXISTS, COUNT, LIMIT, FIRST 및 LAST, PRIOR 및 NEXT, TRIM , DELETE
%ROWTYPE을 사용하면 데이터베이스 테이블의 행(row)과 유형이 동일한 혼합 변수를 선언할 수
있습니다.

연습 5 개요

y INDEX BY 테이블 선언
y INDEX BY 테이블을 사용하여 데이터 처리
y PL/SQL 레코드 선언
y PL/SQL 레코드를 사용하여 데이터 처리
n l y
e O
연습 5 개요
U s
이 연습에서는 INDEX BY 테이블과 PL/SQL 레코드를 정의, 생성 및 사용합니다.
A I
O
l &
n a
te r
I n
c le
ra
O

연습 5
1. 주어진 국가에 대한 정보를 출력하는 PL/SQL 블록을 작성하십시오.
a. COUNTRIES 테이블의 구조를 기반으로 PL/SQL 레코드를 선언하십시오.
b. DEFINE 명령을 사용하여 국가 ID를 지정한 후 그 값을 iSQL*Plus 치환 변수를 통해
c. DBMS_OUTPUT.PUT_LINE을 사용하여 해당 국가에 대해 선택된 정보를
출력하십시오. 다음은 예제 출력 결과입니다.
d. CA, DE, UK, US를 국가 ID로 사용하여 PL/SQL 블록을 실행하고 테스트하십시오.
2. INDEX BY 테이블을 사용해서 DEPARTMENTS 테이블의 각 부서 이름을 검색하여 화면에
출력하는 PL/SQL 블록을 작성하십시오. 그런 다음 Save Script 버튼을 눌러 코드를
p5q2.sql이라는 이름의 파일로 저장하십시오. 스크립트는 .sql 확장자로 저장해야
합니다.
a. 부서 이름을 임시로 저장할 MY_DEPT_TABLE이라는 INDEX BY 테이블을
선언하십시오.
b. 루프를 사용해서 현재 DEPARTMENTS 테이블에 있는 모든 부서 이름을 검색하여
INDEX BY 테이블에 저장하십시오. 다음 표를 사용하여 루프에서 사용되는
카운터의 값에 따라 DEPARTMENT_ID에 대한 값을 할당하십시오.
n l y
e O
COUNTER DEPARTMENT_ID
U s
1
2
10
20
A I
3 50
O
4
l & 60
5
n a 80
c. 다른 루프를 6
te r
DBMS_OUTPUT.PUT_LINE을
7
90 부서 이름을 검색한 후
사용해서 INDEX BY 테이블에서
사용하여110
화면에 출력하십시오. 프로그램의 출력
I n
결과는 다음 페이지의 내용과 같습니다.
c l e
r a
O

연습 5(계속)
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O

연습 5(계속)
3. 연습 2에서 작성한 블록을 수정하여 레코드의 INDEX BY 테이블을 사용해서
DEPARTMENTS 테이블의 각 부서에 대한 모든 정보를 검색하고 화면에 출력하십시오.
a. 모든 부서의 번호, 이름 및 위치를 임시로 저장할 MY_DEPT_TABLE이라는 INDEX
BY 테이블을 선언하십시오.
b. 루프를 사용하여 현재 DEPARTMENTS 테이블에 있는 모든 부서 정보를 검색하여
INDEX BY 테이블에 저장하십시오. 다음 표를 사용하여 루프에서 사용되는
카운터의 값에 따라 DEPARTMENT_ID에 대한 값을 할당합니다. 카운터의 값이
7이 되면 루프를 종료합니다.
COUNTER DEPARTMENT_ID
1 10
2 20
3 50
4 60
5 80
6 90
7 사용하여 INDEX BY 테이블의
c. 다른 루프를 110 부서 정보를 검색한 후
n l y
DBMS_OUTPUT.PUT_LINE을 사용하여 화면에 출력하십시오. 다음은 예제 출력
결과입니다.
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O

명시적 커서 작성
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 암시적 커서(implicit cursor)와 명시적 커서(explicit
cursor) 식별
y 명시적 커서를 사용하는 경우와 그 이유에 대한 설명
y PL/SQL 레코드 변수 사용
y 커서 FOR 루프 작성
n l y
e O
단원 목표
이 단원에서는 암시적 커서(implicit cursor)와 명시적 커서(explicit cursor)의 차이점을 살펴보고
U s
명시적 커서를 사용하는 경우와 그 이유를 설명합니다. 많은 행(row)을 처리하려면 PL/SQL에서
여러 행(row) SELECT 문을 사용해야 하며 이를 위해 명시적 커서를 선언하고 제어합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
커서
Oracle Server에서 실행되는 모든 SQL 문에는 연관된

개별 커서가 있습니다.
y 암시적 커서(implicit cursor): 모든 DML 및 PL/SQL
SELECT 문에 대해 선언됩니다.
y 명시적 커서(explicit cursor): 프로그래머가 선언하고
이름을 지정합니다.
n l y
e O
암시적 커서(implicit cursor)와 명시적 커서(explicit cursor)
Oracle Server는 전용(private) SQL 영역이라고 하는 작업 영역을 사용하여 SQL 문을 실행하고
U s
처리 정보를 저장합니다. PL/SQL 커서를 사용하여 전용 SQL 영역의 이름을 지정하고 이
영역에 저장된 정보를 액세스할 수 있습니다. A I
O
커서 유형
암시적(implicit)
설명
l &
암시적 커서(implicit cursor)는 하나의 행(row)만 반환하는 질의를
a
비롯한 모든 DML 문 및 PL/SQL SELECT 문에 대해 PL/SQL이
n
명시적(explicit)
te r
암시적으로 선언합니다.
둘 이상의 행(row)을 반환하는 질의에 대해 선언합니다. 명시적
I n
커서(explicit cursor)는 프로그래머가 선언하여 이름을 지정하며
블록의 실행 가능한 작업에 있는 명령문을 통하여 조작합니다.
c l e
r a
Oracle Server는 커서를 암시적으로(implicitly) 열어, 명시적으로(explicitly) 선언된 커서와
연관되지 않은 각 SQL 문을 처리합니다. PL/SQL을 사용하면 가장 최근의 암시적 커서(implicit
O
cursor)를 SQL 커서로 참조할 수 있습니다.

명시적 커서(explicit cursor) 기능
테이블
100 King AD_PRES
101 Kochhar AD_VP
활성 집합
102 De Haan AD_VP
커서
. . .
. . .
. . .
139 Seo ST_CLERK
140 Patel ST_CLERK
. . .
n l y
e O
명시적 커서(explicit cursor)
명시적 커서(explicit cursor)를 사용하여 여러 행 SELECT 문에 의해 반환된 각 행(row)을
U s
개별적으로 처리할 수 있습니다.
A I
여러 행(row) 질의에 의해 반환되는 행(row) 집합을 활성 집합이라고 하며 활성 집합의 크기는
O
검색 조건을 만족하는 행(row) 수와 같습니다. 슬라이드의 도표는 명시적 커서(explicit cursor)가
행(row)을 한 번에 하나씩 처리할 수 있습니다.

l &
활성 집합에서 현재 행(row)을 가리키는 방식을 도해한 것입니다. 프로그램은 이런 방법으로
n a
PL/SQL 프로그램은 커서를 열어 질의에 의해 반환되는 행(row)을 처리한 후 커서를 닫습니다.
커서는 활성 집합에서 현재 위치를 표시합니다.
te
명시적 커서(explicit cursor) 기능:
r
I n
y 질의에 의해 반환된 행(row)을 첫번째 행부터 차례로 처리할 수 있습니다.
l e
y 현재 처리 중인 행(row)을 추적합니다.
c
r a
y 프로그래머가 PL/SQL 블록에서 명시적 커서(explicit cursor)를 수동으로 제어할 수
있습니다.
O
명시적 커서(explicit cursor) 제어
아니오
예
DECLARE OPEN FETCH EMPTY? CLOSE
y 명명된 y 활성 집합 y 현재 y 기존 y 활성 집합
SQL 영역 식별 행(row)을 행(row) 해제
생성 변수에 테스트
로드 y 행(row)이
있으면
FETCH로
돌아감
n l y
e O
명시적 커서(explicit cursor)(계속)
이제 커서에 대한 개념적인 이해를 바탕으로 하여 커서 사용 단계를 살펴보겠습니다.
U s
각 단계에 해당하는 구문은 다음 페이지에서 설명합니다.
명시적 커서(explicit cursor) 제어 A I
1. 커서의 이름을 지정하고 커서 내에서 수행될 질의 구조를 정의하여 커서를 선언합니다. O
l &
2. 커서를 엽니다. OPEN 문은 질의를 실행하여 참조되는 모든 변수를 바인드합니다. 질의에
a
의해 식별된 행(row)을 활성 집합이라고 하며 이제 인출(fetch)이 가능합니다.
n
te r
3. 커서에서 데이터를 인출(fetch)합니다. 슬라이드의 순서도에서 볼 수 있듯이, 행(row)을
인출할 때마다 남은 행이 있는지 커서를 테스트하고 처리할 행(row)이 더 이상 없으면
커서를 닫습니다.
I n
4. 커서를 닫습니다. CLOSE 문은 행(row)의 활성 집합을 해제합니다. 이제 커서를 다시 열어
l e
새로운 활성 집합을 생성할 수 있습니다.
c
r a
O
1. 커서를 엽니다.
2. 행(row)을 인출(fetch)합니다.
3. 커서를 닫습니다.
커서
포인터
n l y
e O
OPEN, FETCH 및 CLOSE 문을 사용하여 커서를 제어합니다.
U s
OPEN 문은 커서와 연관된 질의를 실행하여 결과 집합을 식별한 후 커서를 첫번째 행(row) 앞에
A I
위치시킵니다.
O
l &
n a
te r
I n
c le
r a
O
2. 커서를 사용하여 행(row)을 인출합니다.
커서
포인터
커서가 빌 때까지 계속합니다.
n l y
e O
FETCH 문은 현재 행(row)을 검색한 후 행(row)이 더 이상 없거나 지정된 조건이 만족될 때까지
U s
커서를 다음 행(row)으로 이동합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
커서
포인터
n l y
e O
마지막 행(row)이 처리되었으면 커서를 닫습니다. CLOSE 문은 커서를 비활성화합니다.
U s
A I
O
l &
n a
te r
I n
c le
r a
O
커서 선언
구문:
CURSOR cursor_name IS
select_statement;
y 커서 선언에 INTO 절을 포함시키지 마십시오.

y 특정 순서로 행(row)을 처리해야 한다면 질의에 ORDER
BY 절을 사용하십시오.
n l y
e O
커서 선언
CURSOR 문을 사용하여 명시적 커서(explicit cursor)를 선언합니다. 질의에 있는 변수를 참조할
U s
수 있으나 변수는 CURSOR 문 앞에 선언해야 합니다.
A I
구문 설명:
cursor_name PL/SQL 식별자입니다. O
select_statement
l &
INTO 절이 없는 SELECT 문입니다.
참고
n a
te r
y INTO 절은 이후 FETCH 문에 포함되므로 커서 선언에 포함시키지 마십시오.
y 커서는 조인을 포함하는 유효한 ANSI SELECT 문 등이 될 수 있습니다.
I n
c l e
r a
O
커서 선언
예제:
DECLARE
CURSOR emp_cursor IS
SELECT employee_id, last_name
FROM employees;
CURSOR dept_cursor IS
SELECT *
FROM departments
WHERE location_id = 170;
BEGIN
...
n l y
e O
커서 선언(계속)
슬라이드의 예제에서는 커서 emp_cursor를 선언하여 EMPLOYEES 테이블에서
U s
EMPLOYEE_ID와 LAST_NAME 열을 검색합니다. 마찬가지로 커서 DEPT_CURSOR를 선언하여
LOCATION_ID가 170인 부서의 모든 세부 사항을 검색합니다.
A I
DECLARE
O
v_empno
v_ename
employees.employee_id%TYPE;
employees.last_name%TYPE;
l &
n a
FROM employees;
te r
BEGIN
I n
. . .
c le
커서로 검색한 값을 DECLARE 섹션에서 선언한 변수로 인출(fetch)하는 과정은 이 단원
a
뒷부분에서 다룹니다.
r
O
커서 열기
구문:
OPEN cursor_name;
y 커서를 열어 질의를 실행하고 활성 집합을 식별합니다.

y 질의에 의해 반환되는 행(row)이 없는 경우 예외가
발생하지 않습니다.
y 커서 속성을 사용하여 인출(fetch) 후의 결과를
테스트합니다.
n l y
e O
OPEN 문
OPEN 문은 커서와 연관된 질의를 실행하여 결과 집합을 식별한 후 커서를 첫번째 행(row) 앞에
U s
위치시킵니다.
구문 설명:
A I
cursor_name 앞에서 선언한 커서의 이름입니다.
O
OPEN은 다음 작업을 수행하는 실행문입니다.
l &
a
1. 중요한 처리 정보를 포함할 관련 내용 영역(context area)을 위한 메모리를 동적으로
n
할당합니다.
2. SELECT 문을 분석합니다.
te r
I n
3. 입력 변수를 바인드합니다. 즉 해당 메모리 주소를 확보하여 입력 변수의 값을 설정합니다.
l e
4. 활성 집합, 즉 검색 조건을 만족하는 행(row) 집합을 식별합니다. 활성 집합의 행(row)은
OPEN 문에서 변수에 저장하는 것이 아니라 FETCH 문에서 저장하게 됩니다.
c
r a
5. 포인터의 위치를 활성 집합의 첫번째 행(row) 앞으로 지정합니다.
FOR UPDATE 절을 사용하여 커서를 선언한 경우 OPEN 문은 해당 행(row)을 잠급니다. FOR
O
UPDATE 절은 다른 단원에서 설명합니다.
참고: 커서가 열려 있을 때 질의에 의해 반환되는 행(row)이 없으면 예외가 발생하지 않습니다.
그러나 SQL%ROWCOUNT 커서 속성을 사용하면 인출(fetch) 후 커서의 상태를 테스트할 수
있습니다.

커서에서 데이터 인출(fetch)
구문:
FETCH cursor_name INTO [variable1, variable2, ...]

| record_name];
y 현재 행(row) 값을 변수로 가져옵니다.

y 동일한 개수의 변수를 포함합니다.
y 각 변수의 위치는 해당 열의 위치와 대응되어야 합니다.
y 커서의 행(row) 포함 여부를 테스트합니다.
n l y
e O
FETCH 문
FETCH 문은 활성 집합에 있는 행(row)을 한 번에 하나씩 검색합니다. 행(row)을 인출하고 나면
U s
커서는 활성 집합의 다음 행(row)으로 이동합니다.
구문 설명: A I
cursor_name 앞에서 선언한 커서의 이름입니다. O
variable
l &
결과를 저장하는 출력 변수입니다.
record_name
a
검색한 데이터를 저장하는 레코드의 이름이며 레코드
n
지침:
te r
변수는 %ROWTYPE 속성을 사용하여 선언할 수 있습니다.
I
호환되는 데이터 유형을 사용해야 합니다.n
y FETCH 문의 INTO 절에는 SELECT 문의 열과 동일한 개수의 변수가 있어야 하며
l e
y 각 변수의 위치는 해당 열의 위치에 대응되어야 합니다.
c
y 또는 커서에 대한 레코드를 정의하여 FETCH INTO 절에서 해당 레코드를 참조합니다.
r a
y 커서의 행(row) 포함 여부를 테스트합니다. 인출(fetch) 작업에 의해 반환되는 값이 없는
O 경우 활성 집합에 처리할 행(row)이 남아 있지 않은 것이므로 오류가 기록되지 않습니다.

참고: FETCH 문은 다음 작업을 수행합니다.
1. 현재 행(row)의 데이터를 PL/SQL의 출력 변수로 읽어 들입니다.
2. 포인터를 식별된 집합 내의 다음 행(row)으로 이동합니다.

커서에서 데이터 인출(fetch)
예제:
LOOP
FETCH emp_cursor INTO v_empno,v_ename;
EXIT WHEN ...;
...
-- Process the retrieved data
…
END LOOP;
n l y
e O
FETCH 문(계속)
U s
FETCH 문은 현재 행(row) 값을 출력 변수로 가져옵니다. 이렇게 인출한 후에는 변수의
데이터를 조작할 수 있습니다. INTO 목록에는 커서와 연관된 질의에서 반환한 각 열 값에
해당되는 변수가 있어야 하며 데이터 유형도 서로 호환되어야 합니다. A I
처음 10명의 사원을 한 명씩 차례대로 검색합니다. O
SET SERVEROUTPUT ON
l &
DECLARE
n
v_empno employees.employee_id%TYPE;
a
CURSOR
te
emp_cursor IS r
v_ename employees.last_name%TYPE;
FROM
I n
employees;
BEGIN
c l e
OPEN emp_cursor;
r a
FOR i IN 1..10 LOOP
FETCH emp_cursor INTO v_empno, v_ename;
O DBMS_OUTPUT.PUT_LINE (TO_CHAR(v_empno)
||' '|| v_ename);
END LOOP;
END ;

커서 닫기
구문:
CLOSE cursor_name;
y 행(row) 처리를 완료한 후 커서를 닫습니다.

y 필요한 경우 커서를 다시 엽니다.
y 닫혀진 커서에서 데이터 인출(fetch)을 시도하지
마십시오.
n l y
e O
CLOSE 문
CLOSE 문을 실행하면 커서가 비활성화되고 활성 집합은 정의되지 않은 상태로 바뀝니다.
U s
SELECT 문 처리를 완료한 후 커서를 닫습니다. 필요한 경우 닫은 커서를 다시 열 수 있으므로
활성 집합을 여러 번 설정할 수 있습니다.
A I
구문 설명:
O
cursor_name 앞에서 선언한 커서의 이름입니다.
l &
닫혀진 커서에서 데이터 인출(fetch)을 시도하지 마십시오. 인출을 시도하면
INVALID_CURSOR 예외가 발생합니다.
n a
te r
참고: CLOSE 문은 관련 내용 영역(context area)을 해제합니다.
I n
커서를 닫지 않고 PL/SQL 블록을 종료할 수 있지만 자원을 해제시키기 위해서는 선언한
커서를 명시적으로(explicitly) 닫는 것이 좋습니다.
l e
각 사용자에 대해 열리는 최대 커서 수를 제한할 수 있는데 이 값은 데이터베이스 파라미터
c
파일의 OPEN_CURSORS 파라미터로 결정되며 기본적으로 OPEN_CURSORS = 50입니다.
r a
OPEN emp_cursor
O FOR i IN 1..10 LOOP

...
END LOOP;
CLOSE emp_cursor;
END;
명시적 커서(explicit cursor) 속성
커서의 상태 정보를 제공합니다.

속성 유형 설명
%ISOPEN Boolean 커서가 열려 있으면 TRUE로
평가합니다.
%NOTFOUND Boolean 가장 최근의 인출(fetch)에서 행(row)
을 반환하지 않으면 TRUE로
평가합니다.
%FOUND Boolean 가장 최근의 인출(fetch)에서 행(row)
을 반환하면 TRUE로 평가합니다.
%NOTFOUND와 반대입니다.
%ROWCOUNT Number 지금까지 반환된 전체 행(row) 수를
평가합니다.
n l y
e O
명시적 커서(explicit cursor) 속성
명시적 커서(explicit cursor)에는 암시적 커서(implicit cursor)와 마찬가지로 커서에 대한 상태
U s
정보를 얻을 수 있는 네 가지 속성이 있습니다. 이러한 속성을 커서 변수 이름에 추가하면
데이터 조작문 실행에 대한 유용한 정보를 얻을 수 있습니다. A I
참고: SQL 문에서 커서 속성을 직접 참조할 수 없습니다. O
l &
n a
te r
I n
c l e
r a
O
%ISOPEN 속성
y 커서가 열려 있는 경우에만 행(row)을

인출(fetch)합니다.
y %ISOPEN 커서 속성은 인출(fetch) 작업을 수행하기
전에 커서가 열려 있는지 테스트하는 데 사용합니다.
예제:
IF NOT emp_cursor%ISOPEN THEN
OPEN emp_cursor;
END IF;
LOOP
FETCH emp_cursor...
n l y
e O
%ISOPEN 속성
U s
y 커서가 열려 있는 경우에만 행(row)을 인출(fetch)할 수 있으므로 필요한 경우 %ISOPEN
커서 속성을 사용하여 커서가 열려 있는지 확인합니다.
A I
y 루프를 사용하여 행(row)을 인출(fetch)합니다. 커서 속성을 사용하여 루프 종료 시기를
결정합니다. O
y %ROWCOUNT 커서 속성은 다음의 경우에 사용합니다.
l &
− 행(row)의 정확한 개수를 검색할 때
n a
te r
− 숫자 FOR 루프를 사용하여 행(row)을 인출(fetch)할 때
− 단순 루프를 사용하여 행(row)을 인출(fetch)하고 루프 종료 시점을 결정할 때
I n
참고: %ISOPEN은 커서의 상태를 반환하며, 커서가 열려 있으면 TRUE, 닫혀 있으면 FALSE를
반환합니다.
c l e
r a
O
복수 인출(fetch) 제어
y 루프를 사용하여 명시적 커서(explicit cursor)에서

여러 행(row)을 처리합니다.
y 반복될 때마다 행(row)을 인출(fetch)합니다.
y 명시적 커서(explicit cursor) 속성을 사용하여 각
인출(fetch) 작업이 성공적으로 수행되었는지
테스트합니다.
n l y
e O
명시적 커서(explicit cursor)에서 복수 인출(fetch) 제어
U s
명시적 커서(explicit cursor)에서 여러 행(row)을 처리하려면 일반적으로 반복될 때마다
인출(fetch) 작업을 수행하는 루프를 정의합니다. 그러면 활성 집합의 모든 행(row)이 처리되며
인출(fetch) 작업이 실패한 경우 %NOTFOUND 속성이 TRUE로 설정됩니다. 해당 커서를 A I
O
참조하기 전에 명시적 커서(explicit cursor) 속성을 사용하여 각 인출(fetch) 작업이 성공적으로
수행되었는지 테스트하십시오. 종료 조건을 생략하면 무한 루프가 발생합니다.
l &
a
자세한 내용은 PL/SQL User's Guide and Reference, “Interaction With Oracle”을 참조하십시오.
n
te r
I n
c l e
r a
O
%NOTFOUND
및 %ROWCOUNT 속성
y %ROWCOUNT 커서 속성을 사용하여 정확한 행(row)

수를 검색합니다.
y %NOTFOUND 커서 속성을 사용하여 루프 종료 시기를
결정합니다.
n l y
e O
%NOTFOUND 및 %ROWCOUNT 속성
U s
%NOTFOUND
%NOTFOUND는 %FOUND와 논리적으로 반대입니다. %NOTFOUND는 마지막 인출(fetch) 작업이
A I
O
행(row)을 반환한 경우 FALSE를 반환하고 마지막 인출(fetch) 작업이 행(row) 반환에 실패한 경우
TRUE를 반환합니다. 다음 예제에서는 %NOTFOUND를 사용하여 FETCH가 행(row) 반환에
실패하면 루프를 종료합니다.
l &
LOOP
n a
te r
FETCH c1 INTO my_ename, my_sal, my_hiredate;
...
I n
EXIT WHEN c1%NOTFOUND;
END LOOP;
c le
r a
첫번째 인출(fetch) 작업 전에 %NOTFOUND는 NULL이므로, 성공적으로 실행되는 인출(fetch)
O
작업이 없으면 루프가 종료되지 않습니다. WHEN 조건이 TRUE인 경우에만 EXIT WHEN 문이
실행되기 때문입니다. 따라서 안전하게 종료하려면 다음 EXIT 문을 사용하십시오.
EXIT WHEN c1%NOTFOUND OR c1%NOTFOUND IS NULL;
커서가 열려 있지 않을 때 %NOTFOUND로 참조하면 INVALID_CURSOR 오류가 발생합니다.

%NOTFOUND 및 %ROWCOUNT 속성(계속)
%ROWCOUNT
커서나 커서 변수가 열려 있으면 %ROWCOUNT는 영(0)이 됩니다. 첫번째 인출(fetch) 작업을
수행하기 전에 %ROWCOUNT의 결과는 0입니다. 그 뒤로는 지금까지 인출된 행(row) 수를
반환합니다. 마지막 인출(fetch) 작업이 행(row)을 반환하면 이 값이 증가합니다. 다음
예제에서는 %ROWCOUNT를 사용하여 10개가 넘는 행(row)이 인출(fetch)되면 작업을
수행하도록 지정합니다.
LOOP
FETCH c1 INTO my_ename, my_deptno;
IF c1%ROWCOUNT > 10 THEN
...
END IF;
...
END LOOP;
커서가 열려 있지 않을 때 %ROWCOUNT로 참조하면 INVALID_CURSOR 오류가 발생합니다.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
예제
DECLARE
v_empno employees.employee_id%TYPE;
v_ename employees.last_name%TYPE;
FROM employees;
BEGIN
OPEN emp_cursor;
LOOP
EXIT WHEN emp_cursor%ROWCOUNT > 10 OR
emp_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE (TO_CHAR(v_empno)
||' '|| v_ename);
END LOOP;
CLOSE emp_cursor;
END ;
n l y
e O
예제
슬라이드의 예제는 처음 10명의 사원을 한 명씩 검색합니다.
U s
참고: 첫번째 인출(fetch) 작업 전에 %NOTFOUND는 NULL이므로, 성공적으로 실행되는
인출(fetch) 작업이 없으면 루프가 종료되지 않습니다. WHEN 조건이 TRUE인 경우에만 EXIT A I
WHEN 문이 실행되기 때문입니다. 따라서 안전하게 종료하려면 다음 EXIT 문을 사용하십시오. O
&
EXIT WHEN emp_cursor%NOTFOUND OR emp_cursor%NOTFOUND IS NULL;
l
n a
%ROWCOUNT를 사용하는 경우 인출(fetch) 작업에서 아무 행(row)도 검색되지 않으면 행(row)
카운트가 증가하지 않으므로, %NOTFOUND 속성을 사용하여 커서에 행(row)이 없는지
테스트하십시오.
te r
I n
c le
ra
O
커서 및 레코드
값을 PL/SQL 레코드로 인출(fetch)하여 활성 집합의
행(row)을 처리합니다.
DECLARE
FROM employees;
emp_record emp_cursor%ROWTYPE;
BEGIN
OPEN emp_cursor;
LOOP
FETCH emp_cursor INTO emp_record;
...
emp_record
employee_id last_name
100 King
n l y
e O
커서 및 레코드
이미 살펴보았듯이, 테이블의 열과 동일한 구조의 레코드를 정의할 수 있습니다. 또한 명시적
U s
커서(explicit cursor)에서 선택한 열의 목록을 기반으로 레코드를 정의할 수도 있습니다. 이렇게
하면 레코드로 인출(fetch)만 하면 되므로 활성 집합의 행(row)을 쉽게 처리할 수 있습니다.
A I
따라서 행(row)의 값은 레코드의 해당 필드로 직접 로드됩니다.
예제 O
l &
커서를 사용해서 사원 번호와 이름을 검색하여 이 정보로 데이터베이스 테이블 TEMP_LIST를
채웁니다.
n a
r
DECLARE
te
FROM
n
employees;
I
emp_record emp_cursor%ROWTYPE;
BEGIN
l e
OPEN emp_cursor;
LOOP
c
r a
FETCH emp_cursor INTO emp_record;
EXIT WHEN emp_cursor%NOTFOUND;
O INSERT INTO temp_list (empid, empname)

VALUES (emp_record.employee_id, emp_record.last_name);
END LOOP;
COMMIT;
CLOSE emp_cursor;
END;
/
커서 FOR 루프
구문:
FOR record_name IN cursor_name LOOP
statement1;
statement2;
. . .
END LOOP;
y 커서 FOR 루프를 사용하면 명시적 커서(explicit

cursor)를 바로 처리할 수 있습니다.
y 암시적(implicit) 열기, 인출(fetch), 종료 및 닫기를
실행합니다.
y 레코드가 암시적으로(implicitly) 선언됩니다.
n l y
e O
커서 FOR 루프
U s
커서 FOR 루프는 명시적 커서(explicit cursor)의 행을 처리합니다. 커서 FOR 루프에서는 커서가
열리고, 루프가 한 번 반복될 때마다 행이 인출(fetch)되며, 마지막 행이 처리되면 루프가
종료되고, 커서가 자동으로 닫히는 과정이 단축 형태로 수행됩니다. 루프는 마지막 행을 A I
인출하고 반복 작업이 끝나면 자동으로 종료됩니다.
O
구문 설명:
l &
record_name
a
암시적으로(implicitly) 선언된 레코드의 이름입니다.
n
지침
cursor_name
te r
앞에서 선언한 커서의 PL/SQL 식별자입니다.
I n
y 루프를 제어하는 레코드는 암시적으로 선언되므로 선언하지 마십시오.
c l e
y 필요한 경우 루프 도중에 커서 속성을 테스트합니다.
y 필요한 경우 FOR 문에서 커서 이름 뒤에 커서의 파라미터를 괄호로 묶어 제공할 수
r a
있습니다. 커서 파라미터에 대한 자세한 내용은 다음 단원에서 설명합니다.
O y 커서 작업을 명시적으로(explicitly) 처리해야 하는 경우에는 커서 FOR 루프를 사용하지

마십시오.
참고: 루프를 시작할 때 질의를 정의할 수 있습니다. 이 질의 표현식을 SELECT 서브 문이라고
하며 FOR 루프 내에 커서를 포함합니다. 커서는 이름 없이 선언되므로 커서 속성을 테스트할
수 없습니다.

커서 FOR 루프
판매 부서에서 근무하는 사원 명단을 출력합니다.
DECLARE
SELECT last_name, department_id
FROM employees;
BEGIN
FOR emp_record IN emp_cursor LOOP
-- implicit open and implicit fetch occur
IF emp_record.department_id = 80 THEN
...
END LOOP; -- implicit close occurs
END;
/
n l y
e O
예제
U s
사원을 한 명씩 검색하여 현재 판매 부서(DEPARTMENT_ID = 80)에서 근무하고 있는 사원의
목록을 출력합니다. 다음은 슬라이드 예제의 전체 코드입니다.
A I
O
SET SERVEROUTPUT ON
DECLARE
SELECT last_name, department_id
l &
FROM employees;
n a
r
BEGIN
te
FOR emp_record IN emp_cursor LOOP
--implicit open and implicit fetch occur
I n
DBMS_OUTPUT.PUT_LINE ('Employee ' || emp_record.last_name
c l
END IF; e || ' works in the Sales Dept. ');
r END ;a
END LOOP; --implicit close and implicit loop exit
O /

서브 쿼리를 사용하는 커서 FOR 루프
커서를 선언하지 않아도 됩니다.

예제:
BEGIN
FOR emp_record IN (SELECT last_name, department_id
FROM employees) LOOP
-- implicit open and implicit fetch occur
...
END LOOP; -- implicit close occurs
END;
n l y
e O
서브 쿼리를 사용하는 커서 FOR 루프
U s
FOR 루프에서 서브 쿼리를 사용할 경우에는 커서를 선언하지 않아도 됩니다. 이 예제는 앞
페이지의 예제와 동일한 작업을 수행하며 전체 코드는 다음과 같습니다.
A I
O
SET SERVEROUTPUT ON
BEGIN
FROM
l &
FOR emp_record IN (SELECT last_name, department_id
employees) LOOP
n a
--implicit open and implicit fetch occur
te r
DBMS_OUTPUT.PUT_LINE ('Employee ' || emp_record.last_name
END IF;
I n || ' works in the Sales Dept. ');
END ;
c l
END LOOP;
e --implicit close occurs
r
/
a
O
예제
처음 다섯 사원의 업무 이력을 검색합니다.
SET SERVEROUTPUT ON
DECLARE
v_employee_id employees.employee_id%TYPE;
v_job_id employees.job_id%TYPE;
v_start_date DATE;
v_end_date DATE;
SELECT employee_id, job_id, start_date, end_date
FROM job_history
ORDER BY employee_id;
BEGIN
OPEN emp_cursor;
LOOP
FETCH emp_cursor
INTO v_employee_id, v_job_id, v_start_date, v_end_date;
DBMS_OUTPUT.PUT_LINE ('Employee #: ' || v_employee_id ||
' held the job of ' || v_job_id || ' FROM ' ||
v_start_date || ' TO ' || v_end_date);
n l y
EXIT WHEN emp_cursor%ROWCOUNT > 4 OR
emp_cursor%NOTFOUND;
e O
END LOOP;
CLOSE emp_cursor;
U s
END;
/
A I
O
l &
n a
te r
I n
c l e
r a
O
요약

y 커서 유형 식별:
– 암시적 커서(implicit cursor): 모든 DML 문 및 단일
행(row)을 질의할 때 사용합니다.
– 명시적 커서(explicit cursor): 행(row)이 없는 경우 또는
하나 이상의 행을 질의할 때 사용합니다.
y 명시적 커서(explicit cursor) 조작
y 커서 속성을 사용하여 커서 상태를 평가합니다.
y 커서 FOR 루프 사용
n l y
e O
요약
U s
오라클은 작업 영역을 사용하여 SQL 문을 실행하고 처리 정보를 저장합니다. 커서라는
PL/SQL 생성자를 사용하면 작업 영역에 이름을 지정하고 그 영역에 저장된 정보에 액세스할
A I
수 있습니다. 커서에는 암시적 커서(implicit cursor)와 명시적 커서(explicit cursor)의 두 종류가
있습니다. PL/SQL에서는 하나의 행(row)만 반환하는 질의를 비롯한 모든 SQL 데이터
O
l &
조작문에 대해 커서를 암시적으로(implicitly) 선언합니다. 두 개 이상의 행을 반환하는 질의의
경우 커서를 명시적으로(explicitly) 선언하여 각 행(row)을 하나씩 처리할 수 있습니다.
n a
모든 명시적 커서(explicit cursor) 및 커서 변수에는 %FOUND, %ISOPEN, %NOTFOUND,
te r
%ROWCOUNT의 네 가지 속성이 있습니다. 이 속성을 커서나 커서 변수에 추가하면 데이터
조작문의 실행에 대한 유용한 정보를 얻을 수 있습니다. 커서 속성은 프로시저문에만 사용할
n
수 있고 SQL 문에는 사용할 수 없습니다.
I
c l e
r a
O
연습 6 개요

y 명시적 커서(explicit cursor)를 선언하고 사용하여
테이블 행(row) 질의
y 커서 FOR 루프 사용
y 커서 속성을 활용하여 커서 상태 테스트
n l y
e O
연습 6 개요
이 연습에서는 커서에 대한 지식을 적용하여 테이블의 행(row)을 처리하고 커서 FOR 루프를
U s
사용한 결과 값을 다른 테이블에 전달합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
연습 6
1. lab06_1.sql 스크립트에서 사원 급여를 저장할 새 테이블을 생성하기 위한 명령을
실행하십시오.
CREATE TABLE top_dogs
( salary NUMBER(8,2));
2. 최고 급여를 받는 사원을 찾아내는 PL/SQL 블록을 작성하십시오.
a. 숫자 n 값에 대한 입력을 받으십시오. 여기서 n은 EMPLOYEES 테이블에서 상위 몇
명을 검색할 것인지 지정하는 역할을 합니다. 예를 들어 상위 5명을 보려면 5를
입력하십시오.
참고: DEFINE 명령을 사용하여 n에 대한 값을 지정하십시오. 이 값을 iSQL*Plus
치환 변수를 통해 PL/SQL 블록으로 전달하십시오.
b. 루프에서 1단계에서 작성한 iSQL*Plus 치환 파라미터를 사용하여 EMPLOYEES
테이블에서 상위 n명의 급여를 가져오십시오. 급여는 중복되면 안됩니다. 즉 두
사원의 급여가 같다면 급여를 한 번만 선택합니다.
c. 급여를 TOP_DOGS 테이블에 저장하십시오.
d. n = 0이거나 n이 EMPLOYEES 테이블의 사원 수보다 많은 경우와 같은 특수한
경우로 변수를 테스트하십시오. 테스트가 끝날 때마다 매번 TOP_DOGS 테이블을
비웁니다. 다음의 출력 결과는 EMPLOYEES 테이블의 상위 5명의 급여를
나타냅니다.
n l y
e O
U s
A I
O
l &
3. 다음 작업을 수행하는 PL/SQL 블록을 작성하십시오.
n a
a. DEFINE 명령을 사용하여 부서 ID를 지정하고 이 값을 iSQL*Plus 치환 변수를
te r
통해 PL/SQL 변수로 전달하십시오.
I
검색하십시오.n
b. PL/SQL 블록에서 해당 부서에 근무하는 사원의 이름, 급여 및 관리자 ID를
l e
c. 사원의 급여가 5000보다 적고 관리자 ID가 101이나 124 중 하나라면
c<<last_name>> Due for a raise라는 메시지를 표시하십시오. 그렇지 않은
r a 경우에는 <<last_name>> Not due for a raise라는 메시지를

표시하십시오.
O 참고: SET ECHO OFF를 설정하여 스크립트를 실행할 때마다 PL/SQL 코드가 표시되는
것을 방지하십시오.

연습 6(계속)
d. 다음 각 사례에 대해 PL/SQL 블록을 테스트하십시오.
부서 ID 메시지
10 Whalen Due for a raise
20 Hartstein Not Due for a raise
Fay Not Due for a raise
50 Weiss Not Due for a raise
Fripp Due for a raise
Kaufling Due for a raise
Vollman Due for a raise
Mourgas Due for a raise
. . .
. . .
80 Russel Not Due for a raise
Partners Not Due for a raise
Errazuriz Not Due for a raise
Cambrault Not Due for a raise
. . .
. . .
n l y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
고급 명시적 커서 개념
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 파라미터를 사용하는 커서 작성
y 커서에서 FOR UPDATE 절이 필요한 경우 판별
y WHERE CURRENT OF 절을 사용하는 경우 판별
y 서브 쿼리를 사용하는 커서 작성
n l y
e O
단원 목표
이 단원에서는 명시적 커서(explicit cursor) 작성, 특히 파라미터를 사용하는 커서 작성에 대해
U s
설명합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
파라미터 사용 커서
구문:
CURSOR cursor_name
[(parameter_name datatype, ...)]
IS
select_statement;
y 커서가 열리고 질의가 실행되면 커서에 파라미터 값을

전달합니다.
y 매번 다른 활성 집합을 사용하여 명시적 커서(explicit
cursor)를 여러 번 엽니다.
OPEN cursor_name(parameter_value,.....) ;
n l y
e O
커서 FOR 루프에 있는 커서에 파라미터를 전달할 수 있습니다. 즉 블록에서 명시적
U s
커서(explicit cursor)를 여러 번 열고 닫으면서 매번 다른 활성 집합을 반환할 수 있습니다.
실행될 때마다 이전 커서는 닫히고 새 파라미터 집합을 사용해 커서가 다시 열립니다. A I
커서 선언의 커서 선언의 각 형식 매개변수는 반드시 OPEN 문의 실제 매개변수와 대응되어야 O
합니다. 이러한 파라미터 데이터 유형은 스칼라 변수의 데이터 유형과 동일하지만 크기는
l
지정되지 않습니다. 파라미터 이름은 커서의 질의 표현식에서 해당 파라미터를 참조할 때&
사용합니다.
n a
구문 설명:
cursor_name
te r
앞에서 선언한 커서의 PL/SQL 식별자입니다.
parameter_name
I n 파라미터의 이름입니다.
parameter_name
datatype
c l e 파라미터의 스칼라 데이터 유형입니다.
r a
select_statement INTO 절이 없는 SELECT 문입니다.
O
커서가 열리면 위치나 이름을 사용하여 각 파라미터에 값을 전달합니다. 전달할 값은 리터럴
값 뿐만 아니라 PL/SQL이나 호스트 변수의 값도 가능합니다.
참고: 파라미터 표기법을 사용하면 입력 값을 쉽고 명확하게 지정할 수 있지만 그 이상의
기능은 사용할 수 없습니다. 파라미터 표기법은 동일한 커서를 반복적으로 참조할 때 특히
유용합니다.
커서 SELECT 문에서 부서 번호 및 직위를 WHERE 절에

전달합니다.
DECLARE
CURSOR emp_cursor
(p_deptno NUMBER, p_job VARCHAR2) IS
FROM employees
WHERE department_id = p_deptno
AND job_id = p_job;
BEGIN
OPEN emp_cursor (80, 'SA_REP');
. . .
CLOSE emp_cursor;
OPEN emp_cursor (60, 'IT_PROG');
. . .
END;
n l y
e O
파라미터 데이터 유형은 스칼라 변수의 데이터 유형과 동일하지만 크기는 지정할 수 없습니다.
U s
파라미터 이름은 커서의 질의에서 해당 파라미터를 참조할 때 사용합니다. 다음 예제에서는
커서를 선언하고 두 개의 파라미터를 사용해 정의합니다. A I
DECLARE O
l &
CURSOR emp_cursor(p_deptno NUMBER, p_job VARCHAR2) IS
SELECT ...
n a
te r
다음 명령문은 커서를 열고 서로 다른 여러 활성 집합을 반환합니다.
OPEN emp_cursor(60, v_emp_job);
I n
OPEN emp_cursor(90, 'AD_VP');
DECLARE
c l e
커서 FOR 루프에 사용되는 커서에 파라미터를 전달할 수 있습니다.
r a
CURSOR emp_cursor(p_deptno NUMBER, p_job VARCHAR2) IS
OBEGIN
SELECT ...
FOR emp_record IN emp_cursor(50, 'ST_CLERK') LOOP ...

FOR UPDATE 절
구문:
SELECT ...
FROM ...
FOR UPDATE [OF column_reference][NOWAIT];
y 명시적(explicit) 잠금을 사용하여 트랜잭션 기간 동안

액세스를 거부할 수 있습니다.
y 갱신 또는 삭제 전에 행(row)을 잠급니다.
n l y
e O
FOR UPDATE 절
행(row)을 갱신하거나 삭제하기 전에 잠글 수 있습니다. 커서 질의에 FOR UPDATE 절을 추가하면
U s
해당 커서를 열 때 영향을 받는 행을 잠글 수 있습니다. Oracle Server는 트랜잭션을 종료할 때
잠금을 해제하므로 FOR UPDATE를 사용할 경우에는 명시적 커서(explicit cursor)에서의
A I
인출(fetch) 작업 사이에 커밋을 수행하지 마십시오.
구문 설명: O
column_reference
l &
질의가 수행되는 테이블 열이며 열 목록을 사용할 수도 있습니다.
NOWAIT
n a
다른 세션에서 해당 행을 잠근 경우 오라클 오류를 반환합니다.
te r
FOR UPDATE 절은 SELECT 문의 맨 마지막에 오며 ORDER BY가 있더라도 그 뒤에 와야 합니다.
여러 테이블을 질의할 경우 FOR UPDATE 절을 사용하여 행(row) 잠금을 특정 테이블로만 제한할
I n
수 있습니다. 이 때 FOR UPDATE 절이 해당 테이블의 열을 참조하는 경우에만 테이블 행이
행을 잠급니다.
c l e
잠깁니다. 즉 FOR UPDATE OF col_name(s)은 col_name(s)이 들어 있는 테이블에서만
r a
SELECT ... FOR UPDATE 문은 갱신 또는 삭제될 행을 식별한 다음 결과 집합에 있는 각 행을
잠급니다. 행의 기존 값을 기반으로 갱신을 수행하려는 경우에는 갱신 전에 다른 사용자가 해당
O
행을 변경하는 것을 방지해야 하므로 이 기능을 사용하면 유용합니다.
선택적 키워드인 NOWAIT를 지정하면 요청된 행을 다른 사람이 잠근 경우 오라클에서 이를
사용하기 위해 대기하지 않습니다. 따라서 제어가 곧바로 프로그램으로 되돌아가 다른 작업을
수행한 후 다시 잠금을 시도합니다. NOWAIT 키워드를 생략하면 오라클은 행을 사용할 수 있을
때까지 대기합니다.
FOR UPDATE 절
부서 번호 80인 부서에서 근무하는 사원을 검색하여

급여를 갱신합니다.
DECLARE
SELECT employee_id, last_name, department_name
FROM employees,departments
WHERE employees.department_id =
departments.department_id
AND employees.department_id = 80
FOR UPDATE OF salary NOWAIT;
n l y
e O
FOR UPDATE 절(계속)
참고: Oracle Server는 SELECT FOR UPDATE에서 필요한 행(row)을 잠글 수 없을 경우 무한정
U s
기다립니다. SELECT FOR UPDATE 문에 NOWAIT 절을 사용하면 루프에서 잠금을 수행하지
못해 반환되는 오류 코드를 테스트할 수 있습니다. 따라서 PL/SQL 블록을 종료하기 전에 커서 A I
열기를 n번 정도 다시 시도해 볼 수 있습니다. 대형 테이블인 경우에는 LOCK TABLE 문으로
O
l &
테이블의 모든 행을 잠그면 더 좋은 성능을 얻을 수 있습니다. 그러나 LOCK TABLE을
사용하면 WHERE CURRENT OF 절을 사용할 수 없으므로 WHERE 열 = 식별자 표기법을
사용해야 합니다.
n a
위해 열을 참조하는 것이 좋습니다.
te r
FOR UPDATE OF 절이 반드시 열을 참조해야 하는 것은 아니지만 가독성 및 유지 관리 향상을
I n
참고: WHERE CURRENT OF 절은 이 단원 뒷부분에서 설명합니다.
c le
FOR UPDATE 절은 갱신 또는 삭제할 행을 식별한 다음 결과 집합에 있는 각 행을 잠급니다.
행의 기존 값을 기반으로 갱신을 수행하려는 경우에는 갱신 전에 다른 사용자가 해당 행을
a
변경하는 것을 방지해야 하므로 이 기능을 사용하면 유용합니다.
r
O
WHERE CURRENT OF 절
구문:
WHERE CURRENT OF cursor ;
y 커서를 사용하여 현재 행(row)을 갱신 및 삭제합니다.

y 커서 질의에 FOR UPDATE 절을 포함시켜 먼저 행을
잠급니다.
y WHERE CURRENT OF 절을 사용하여 명시적
커서(explicit cursor)에서 현재 행을 참조합니다.
n l y
e O
명시적 커서(explicit cursor)에서 현재 행(row)을 참조할 때 WHERE CURRENT OF 절을 사용하면
U s
ROWID를 명시적으로 참조하지 않아도 현재 표시된 행을 갱신 또는 삭제할 수 있습니다. 이 때
커서 질의에 반드시 FOR UPDATE 절을 포함시킴으로써 OPEN 문이 실행될 때 행이 잠기도록
A I
해야 합니다.
O
구문 설명:
l &
cursor
a
선언된 커서의 이름입니다. 이 커서는 FOR UPDATE 절을
n
사용하여 선언된 커서여야 합니다.
te r
I n
c le
r a
O
DECLARE
CURSOR sal_cursor IS
SELECT e.department_id, employee_id, last_name, salary
FROM employees e, departments d
WHERE d.department_id = e.department_id
and d.department_id = 60
FOR UPDATE OF salary NOWAIT;
BEGIN
FOR emp_record IN sal_cursor
LOOP
IF emp_record.salary < 5000 THEN
UPDATE employees
SET salary = emp_record.salary * 1.10
WHERE CURRENT OF sal_cursor;
END IF;
END LOOP;
END;
/
n l y
e O
WHERE CURRENT OF 절(계속)
U s
예제
슬라이드의 예제는 부서 번호 60에 속하는 사원에 대해 루프를 수행하여 급여가 5000보다
적은지 검사한 후 급여가 5000보다 적으면 10% 인상합니다. UPDATE 문의 WHERE CURRENT A I
OF 절은 현재 인출(Fetch)된 레코드를 참조합니다. 커서 선언에 조인이 있을지라도 WHERE O
&
CURRENT OF 절을 사용하면 테이블을 갱신할 수 있다는 점에 주목하십시오.
l
n a
또한 DELETE 또는 UPDATE 문에 WHERE CURRENT OF cursor_name 절을 포함시켜 가장
최근에 FETCH 문으로 처리한 행(row)을 참조할 수 있습니다. 그리고 커서의 조건을 기준으로
te r
행을 갱신할 수 있습니다. 이 절을 사용할 경우에는 참조 커서가 반드시 존재해야 하고 커서
질의에 FOR UPDATE 절이 있어야 오류가 발생하지 않습니다. 이 절을 사용하면 ROWID 의사
I n
열을 명시적으로(explicitly) 참조하지 않고도 현재 표시된 행을 갱신 및 삭제할 수 있습니다.
c le
r a
O
서브 쿼리 포함 커서
예제:
DECLARE
CURSOR my_cursor IS
SELECT t1.department_id, t1.department_name,
t2.staff
FROM departments t1, (SELECT department_id,
COUNT(*) AS STAFF
FROM employees
GROUP BY department_id) t2
WHERE t1.department_id = t2.department_id
AND t2.staff >= 3;
...
n l y
e O
서브 쿼리 포함 커서
서브 쿼리는 다른 SQL 데이터 조작문 내에 들어 있는 질의(보통 괄호로 묶어 지정)입니다. 서브
U s
쿼리를 평가한 결과로 나타나는 값이나 값 집합은 외부 질의에 제공됩니다. 서브 쿼리는
SELECT 문의 WHERE 절에 자주 사용되며, FROM 절에 사용되어 해당 질의에 대한 임시 데이터
A I
소스를 생성하기도 합니다.
O
l &
이 예제에서 서브 쿼리는 부서 번호와 각 부서의 사원 수(별칭 STAFF)로 구성된 데이터 소스를
생성합니다. 테이블 별칭인 t2는 FROM 절에서 이 임시 데이터 소스를 참조합니다. 이 커서가
a
열리면 소속된 사원이 세 명 이상인 부서의 부서 번호, 부서 이름 그리고 해당 부서에 속한 사원
n
수가 활성 집합에 포함됩니다.
te r
I n
c le
r a
O
요약

배웠습니다.
y 파라미터 사용 커서로 서로 다른 여러 활성 집합 반환
y 서브 쿼리 및 상관 서브 쿼리를 사용하여 커서 정의
y 명령에 다음을 포함시킴으로써 명시적 커서(explicit
cursor) 조작
– FOR UPDATE 절
– WHERE CURRENT OF 절
n l y
e O
요약
명시적 커서(explicit cursor)에 파라미터를 사용할 수 있습니다. 질의에서 상수를 사용할 수 있는
U s
모든 위치에 커서 파라미터를 지정할 수 있습니다. 파라미터를 사용하면 실행 중에 활성
집합을 결정할 수 있는 장점이 있습니다. A I
PL/SQL에서는 커서에서 검색한 행(row)을 수정할 수 있는 방식을 제공합니다. 이 방식은 두 O
l &
부분으로 나뉘는데 하나는 커서 선언에 FOR UPDATE 절을 사용하는 것이고 다른 하나는
UPDATE 또는 DELETE 문에 WHERE CURRENT OF 절을 사용하는 것입니다.
n a
te r
I n
c le
r a
O
연습 7 개요

y 파라미터를 사용하는 명시적 커서(explicit cursor)의
선언 및 사용
y FOR UPDATE 커서 사용
n l y
e O
연습 7 개요
이 연습에서는 파라미터 사용 커서에 대한 지식을 활용하여 여러 테이블의 많은 행(row)을
U s
처리합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
연습 7
1. 루프에 커서를 사용하여 DEPARTMENTS 테이블에서 DEPARTMENT_ID가 100보다 작은
부서의 부서 번호와 부서 이름을 검색하십시오. 검색한 부서 번호를 다른 커서로 전달하여
그 부서에서 근무하며 EMPLOYEE_ID가 120보다 작은 사원의 이름, 업무, 입사일 및
급여와 같은 세부 사항을 EMPLOYEES에서 검색하십시오.
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O
연습 7(계속)
2. sol04_4.sql을 수정하여 커서 처리에 FOR UPDATE 및 WHERE CURRENT OF

기능을 사용하는 커서를 이용하십시오.
a. 호스트 변수를 정의하십시오.
DEFINE p_empno=104
DEFINE p_empno=174
DEFINE p_empno=176
b. 수정된 PL/SQL 블록을 실행하십시오.

c. 다음 명령을 실행하여 PL/SQL이 제대로 실행되었는지 확인하십시오.
SELECT employee_id,salary,stars
FROM EMP
WHERE employee_id IN (176,174,104);
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
예외 처리
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y PL/SQL 예외 정의
y 처리되지 않은 예외 인식
y 여러 유형의 PL/SQL 예외 처리기 나열 및 사용
y 예기치 않은 오류 트랩
y 중첩 블록에서 예외 전달이 미치는 영향 설명
y PL/SQL 예외 메시지 사용자 정의
n l y
e O
단원 목표
이 단원에서는 PL/SQL 예외에 대해 설명하고 미리 정의된 처리기, 미리 정의되지 않은 처리기,
U s
사용자가 정의한 예외 처리기를 사용하여 예외를 처리하는 방법을 설명합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
PL/SQL로 예외 처리
y 예외는 실행 중에 발생되는 PL/SQL 식별자입니다.

y 예외 발생
− 오라클 오류가 발생합니다.
− 사용자가 명시적으로(explicitly) 발생시킵니다.
y 처리 방법
− 처리기로 트랩합니다.
− 호출 환경으로 전달합니다.
n l y
e O
개요
예외는 블록 실행 중에 발생하는 PL/SQL 식별자로서 작업의 몸체(body)를 종료합니다.
U s
PL/SQL에서 예외가 발생하면 항상 블록이 종료되지만 예외 처리기를 지정하여 마지막 작업을
수행할 수 있습니다. A I
예외를 발생시키는 두 가지 방식 O
&
y 오라클 오류가 발생하면 연결된 예외가 자동으로 발생합니다. 예를 들어, SELECT 문을
l
n a
실행했을 때 데이터베이스에서 행(row)이 검색되지 않아 ORA-01403 오류가 발생하면
PL/SQL이 NO_DATA_FOUND라는 예외를 발생시킵니다.
te r
y 블록 내에서 RAISE 문을 실행하여 예외를 명시적으로(explicitly) 발생시킬 수 있습니다.
이런 예외는 사용자가 정의한 것일 수도 있고 미리 정의된 것일 수도 있습니다.
I n
c l e
r a
O
예외 처리
예외 트랩 예외 전달
DECLARE DECLARE
BEGIN BEGIN
예외 발생 예외 발생
EXCEPTION EXCEPTION
예외 트랩 예외가
END; END; 트랩되지
않음
예외를 호출
환경으로 전달
n l y
e O
예외 트랩
블록의 실행 부분에서 예외가 발생하면 블록의 EXCEPTION 섹션에 있는 해당 예외 처리기로
U s
처리가 분기됩니다. PL/SQL이 예외를 성공적으로 처리한 경우에는 예외가 상위 블록 또는
환경으로 전달되지 않고 PL/SQL 블록이 성공적으로 종료됩니다. A I
예외 전달 O
&
블록의 실행 부분에서 예외가 발생했는데 해당하는 예외 처리기가 없으면 PL/SQL 블록은
l
실패하고 예외는 호출 환경으로 전달됩니다.
n a
te r
I n
c le
r a
O
예외 유형
}
y 미리 정의된 Oracle Server 예외 암시적으로
(implicitly)
y 미리 정의되지 않은 Oracle Server 예외 발생
y 사용자가 정의한 예외 명시적으로(explicitly) 발생
n l y
e O
예외 유형
예외를 프로그래밍하면 실행 중단을 방지할 수 있습니다. 예외에는 다음 세 가지 유형이
U s
있습니다.
A I
예외 설명
O 처리 지침
l&
미리 정의된 Oracle PL/SQL 코드에서 자주 Oracle Server가
Server 오류 발생하는 약 20가지 오류 중 암시적으로(implicitly)
하나입니다.
n a 발생시키므로 선언하지
미리 정의되지 않은
t e r
다른 표준 Oracle Server
마십시오.
선언 부분에서 선언하고 Oracle
Oracle Server 오류
e In 오류입니다. Server가 암시적으로(implicitly)

발생시킵니다.
사용자가 정의한
c l 개발자가 비정상이라고 선언 부분에서 선언하고
오류
r a 판단하는 조건입니다. 명시적으로(explicitly)
발생시킵니다.
O
참고: 클라이언트측 PL/SQL을 사용하는 일부 응용 프로그램 툴(예: Oracle Developer
Forms)에는 고유한 예외가 있습니다.

예외 트랩
구문:
EXCEPTION
WHEN exception1 [OR exception2 . . .] THEN
statement1;
statement2;
. . .
[WHEN exception3 [OR exception4 . . .] THEN
statement1;
statement2;
. . .]
[WHEN OTHERS THEN
statement1;
statement2;
. . .]
n l y
e O
예외 트랩
PL/SQL 블록의 예외 처리 부분에 해당 루틴을 포함시켜 오류를 트랩할 수 있습니다. 각
U s
처리기는 예외를 지정하는 WHEN 절과 예외 발생 시 실행될 일련의 명령문으로 구성됩니다.
A I
구문 설명:
exception 미리 정의된 예외의 표준 이름 또는 사용자가 선언 부분에 정의한 O
예외의 이름입니다.
l &
statement
a
하나 이상의 PL/SQL 또는 SQL 문입니다.
n
OTHERS
te r
지정되지 않은 예외를 트랩하는 선택적 예외 처리 절입니다.
I
WHEN OTHERS 예외 처리기
n
c le
예외 처리 부분은 지정된 예외만 트랩하므로 다른 예외는 OTHERS 예외 처리기로 트랩해야
합니다. OTHERS 예외 처리기는 앞에서 처리되지 않은 예외를 모두 트랩하므로 마지막으로
r a
정의하는 예외 처리기입니다.
OTHERS 처리기는 앞에서 트랩되지 않은 모든 예외를 트랩합니다. 일부 오라클 툴에는
O
프로그램에서 이벤트를 발생시킬 수 있는 미리 정의된 자체 예외가 있는데, OTHERS는 이러한
예외도 트랩합니다.

예외 트랩 지침
y EXCEPTION 키워드는 예외 처리 부분을 시작합니다.

y 여러 개의 예외 처리기를 사용할 수 있습니다.
y 처리기를 하나만 거치고 블록을 종료합니다.
y WHEN OTHERS는 마지막 절입니다.
n l y
e O
지침
y EXCEPTION 키워드로 블록의 예외 처리 부분을 시작합니다.
U s
y 블록에 대해 각각 고유의 작업 집합을 가진 여러 개의 예외 처리기를 정의합니다.
A I
y 예외가 발생하면 PL/SQL은 하나의 처리기만 거치고 블록을 종료합니다.
O
y OTHERS 절은 다른 모든 예외 처리 절 뒤에 둡니다.
y OTHERS 절은 하나만 사용할 수 있습니다.
l &
n
y 할당문 또는 SQL 문에는 예외를 사용할 수 없습니다. a
te r
I n
c le
r a
O
미리 정의된 Oracle Server 오류 트랩
y 예외 처리 루틴에서 표준 이름을 참조합니다.

y 미리 정의된 예외의 예
– NO_DATA_FOUND
– TOO_MANY_ROWS
– INVALID_CURSOR
– ZERO_DIVIDE
– DUP_VAL_ON_INDEX
n l y
e O
미리 정의된 Oracle Server 오류 트랩
해당하는 예외 처리 루틴에서 표준 이름을 참조하여 미리 정의된 Oracle Server 오류를
U s
트랩합니다.
A I
미리 정의된 예외의 전체 목록은 PL/SQL User's Guide and Reference, “Error Handling”을
참조하십시오. O
l &
참고: PL/SQL에서는 STANDARD 패키지에서 미리 정의된 예외를 선언합니다.
a
가장 일반적인 NO_DATA_FOUND 및 TOO_MANY_ROWS 예외는 항상 처리하는 것이 좋습니다.
n
te r
I n
c l e
r a
O
미리 정의된 예외
예외 이름 Oracle Server 설명
오류 번호
ACCESS_INTO_NULL ORA-06530 초기화되지 않은 객체의 속성에 값을
할당하려고 했습니다.
CASE_NOT_FOUND ORA-06592 CASE 문의 WHEN 절에서 아무것도
선택되지 않았으며 ELSE 절이 없습니다.
COLLECTION_IS_NULL ORA-06531 초기화되지 않은 중첩 테이블 또는 가변
배열에 EXISTS 이외의 Collection 메소드를
적용하려고 했습니다.
CURSOR_ALREADY_OPEN ORA-06511 이미 열려 있는 커서를 열려고 했습니다.
DUP_VAL_ON_INDEX ORA-00001 중복 값을 삽입하려고 했습니다.
INVALID_CURSOR ORA-01001 잘못된 커서 작업이 발생했습니다.
INVALID_NUMBER ORA-01722 문자열을 숫자로 변환하지 못했습니다.
LOGIN_DENIED ORA-01017 오라클에 유효하지 않은 사용자 이름 또는
암호로 로그온했습니다.
NO_DATA_FOUND ORA-01403 단일 행(row) SELECT에서 데이터를
반환하지 않았습니다.
n l y
NOT_LOGGED_ON ORA-01012
e
않은 상태에서 데이터베이스 호출을
O
PL/SQL 프로그램이 오라클에 연결하지
실행했습니다.
U s
PL/SQL에 내부 문제가 있습니다.
I
PROGRAM_ERROR ORA-06501
ROWTYPE_MISMATCH ORA-06504
O A
할당에 사용된 PL/SQL 커서 변수 및
호스트 커서 변수에 호환되지 않는 반환
유형이 있습니다.
l &
n a
te r
I n
c l e
r a
O
미리 정의된 예외(계속)
예외 이름 Oracle Server 설명
오류 번호
STORAGE_ERROR ORA-06500 PL/SQL에 메모리가 부족하거나 메모리가
손상되었습니다.
SUBSCRIPT_BEYOND_COUNT ORA-06533 Collection에 있는 요소의 수보다 큰
인덱스 번호를 사용하여 중첩 테이블
또는 가변 배열 요소를 참조했습니다.
SUBSCRIPT_OUTSIDE_LIMIT ORA-06532 범위를 벗어난 인덱스 번호(예: -1)를
사용하여 중첩 테이블 또는 가변 배열
요소를 참조했습니다.
SYS_INVALID_ROWID ORA-01410 문자열이 유효한 ROWID를 나타내지
않아서 문자열을 범용 ROWID로 변환하지
못했습니다.
TIMEOUT_ON_RESOURCE ORA-00051 오라클이 자원을 기다리는 동안 시간
초과가 발생했습니다.
y
단일 행(row) SELECT에서 둘 이상의 행을
TOO_MANY_ROWS ORA-01422
반환했습니다.
n l
O
산술, 변환, 절단 또는 크기 제약 조건
VALUE_ERROR ORA-06502
오류가 발생했습니다.
ZERO_DIVIDE ORA-01476 0으로 나누려고 했습니다.
se
I U
O A
l &
n a
te r
I n
c l e
r a
O
미리 정의된 예외
구문:
BEGIN
. . .
EXCEPTION
WHEN NO_DATA_FOUND THEN
statement1;
statement2;
WHEN TOO_MANY_ROWS THEN

statement1;
WHEN OTHERS THEN
statement1;
statement2;
statement3;
END;
n l y
e O
미리 정의된 Oracle Server 예외 트랩
예외가 발생하면 PL/SQL 블록이나 서브 프로그램의 정상적인 실행이 중단되고 슬라이드
U s
예제와 같은 형식의 예외 처리 부분으로 제어가 이전됩니다.
A I
발생한 예외를 처리하려면 예외 처리기를 작성해야 합니다. 각 처리기는 예외를 지정하는
WHEN 절과 예외 발생 시 실행되는 일련의 명령문으로 구성됩니다. 이런 명령문이 블록이나 O
않습니다. 즉, 예외가 발생한 지점으로 되돌아가 처리를 재개할 수 없습니다.
l &
서브 프로그램의 실행을 완료하므로 해당 예외가 발생했던 위치로 제어가 되돌아가지는
n a
선택적 예외 처리기인 OTHERS는 항상 블록이나 서브 프로그램의 맨 마지막 처리기로
te r
사용되며 특별히 이름을 지정하지 않은 모든 예외의 처리기 역할을 합니다. 따라서 블록이나
서브 프로그램에는 하나의 OTHERS 처리기만 사용할 수 있습니다. 다음 예제에서 볼 수 있듯이,
I n
OTHERS 처리기를 사용하면 예외를 빠짐 없이 처리할 수 있습니다.
EXCEPTION
c l
WHEN ... THENe
r a
-- handle the error
O
WHEN ... THEN
-- handle the error
WHEN OTHERS THEN
-- handle all other errors
END;
미리 정의되지 않은 Oracle Server 오류 트랩
선언 연결 참조
선언 부분 예외 처리 부분
예외 이름 지정 PRAGMA 발생한 예외 처리
EXCEPTION_INIT 코딩
n l y
e O
미리 정의되지 않은 Oracle Server 오류를 트랩하려면 이러한 오류를 먼저 선언하거나 OTHERS
U s
처리기를 사용해야 합니다. 선언한 예외는 암시적으로(implicitly) 발생됩니다. PL/SQL에서
PRAGMA EXCEPTION_INIT는 예외 이름과 오라클 오류 번호를 연결하도록 컴파일러에
A I
지시하므로 모든 내부 예외를 이름으로 참조하여 각 예외 별로 고유 처리기를 작성할 수
O
있습니다.
l &
참고: PRAGMA (의사 명령어라고도 함)는 해당 명령문이 컴파일러 지시어임을 나타내는
a
키워드로서, PL/SQL 블록을 실행할 때 처리되는 것이 아니라 PL/SQL 컴파일러가 블록 안의
n
r
모든 예외 이름을 연관된 Oracle Server 오류 번호로 해석하도록 지시합니다.
te
I n
c l e
r a
O
미리 정의되지 않은 오류
Oracle Server 오류 번호 -2292(무결성 제약 조건 위반)를
트랩합니다.
DEFINE p_deptno = 10
DECLARE 1
e_emps_remaining EXCEPTION;
PRAGMA EXCEPTION_INIT
(e_emps_remaining, -2292);
2
BEGIN
DELETE FROM departments
WHERE department_id = &p_deptno;
COMMIT;
EXCEPTION
WHEN e_emps_remaining THEN
3
DBMS_OUTPUT.PUT_LINE ('Cannot remove dept ' ||
TO_CHAR(&p_deptno) || '. Employees exist. ');
END;
n l y
e O
1. 선언 부분에 예외의 이름을 선언합니다.
U s
구문
A I
exception EXCEPTION;
O
설명: exception 예외의 이름입니다.
l &
2. PRAGMA EXCEPTION_INIT 문을 사용하여 앞에서 선언한 예외와 표준 Oracle Server
오류 번호를 연결합니다.
n a
구문
te r
PRAGMA
설명:
I n
EXCEPTION_INIT(exception, error_number);
exception 앞에서 선언한 예외입니다.
cl e
error_number 표준 Oracle Server 오류 번호입니다.
예제 r a
3. 선언한 예외를 해당 예외 처리 루틴에서 참조합니다.
O
부서에 사원이 있을 경우 부서를 삭제할 수 없다는 메시지를 출력하십시오.

예외 트랩 함수
y SQLCODE: 오류 코드의 숫자 값을 반환합니다.

y SQLERRM: 오류 번호와 연관된 메시지를 반환합니다.
n l y
e O
오류 트랩 함수
예외가 발생하면 두 가지 함수를 사용하여 연관된 오류 코드 또는 오류 메시지를 식별할 수
U s
있습니다. 이 코드 값 또는 메시지를 기준으로 오류에 대해 수행할 이후 작업을 결정할 수
있습니다. A I
SQLCODE는 내부 예외에 대한 오라클 오류 번호를 반환하며 이 오류 번호를 SQLCODE에 O
전달하면 오류 번호와 연관된 메시지가 반환됩니다.
l &
함수 설명
n a
SQLCODE
있습니다.
te r
오류 코드의 숫자 값을 반환합니다. NUMBER 변수에 이 값을 할당할 수
SQLERRM
I n
오류 번호와 연관된 메시지의 문자 데이터를 반환합니다.
c
SQLCODE 값 예제
l e
SQLCODE 값
0 r a 설명
예외가 발생하지 않았습니다.
1
+100
O 사용자가 정의한 예외입니다.
NO_DATA_FOUND 예외입니다.
음수 다른 Oracle Server 오류 번호입니다.

예외 트랩 함수
예제:
DECLARE
v_error_code NUMBER;
v_error_message VARCHAR2(255);
BEGIN
...
EXCEPTION
...
WHEN OTHERS THEN
ROLLBACK;
v_error_code := SQLCODE ;
v_error_message := SQLERRM ;
INSERT INTO errors
VALUES(v_error_code, v_error_message);
END;
n l y
e O
오류 트랩 함수(계속)
WHEN OTHERS 예외 처리기에서 예외가 트랩되면 일반 함수 집합을 사용해 해당 오류를 식별할
U s
수 있습니다. 슬라이드의 예제는 SQLCODE 및 SQLERRM을 변수에 할당하고 그 변수를 SQL
문에 사용하는 예입니다. A I
SQLCODE 또는 SQLERRM 은 SQL 문에 직접 사용할 수 없습니다. 다음 예제처럼, 그 값을 지역O
변수에 할당한 다음 해당 변수를 SQL 문에 사용해야 합니다.
l &
DECLARE
err_num NUMBER;
n a
err_msg VARCHAR2(100);
BEGIN
te r
n
...
EXCEPTION
...
e I
c l
WHEN OTHERS THEN
err_num := SQLCODE;
r a
err_msg := SUBSTR(SQLERRM, 1, 100);
INSERT INTO errors VALUES (err_num, err_msg);
O
END;

사용자가 정의한 예외 트랩
Declare 발생 참조
선언 부분 실행 부분 예외 처리 부분
예외 이름 지정 RAISE 문을 사용하여 발생된 예외 처리

명시적으로(explicitly) 예외
발생
n l y
e O
사용자가 정의한 예외 트랩
PL/SQL을 사용하여 고유한 예외를 정의할 수 있으며 사용자가 정의한 PL/SQL 예외는 다음과
U s
같아야 합니다.
y PL/SQL 블록의 선언 부분에서 선언해야 합니다. A I
y RAISE 문을 사용하여 명시적으로(explicitly) 발생시켜야 합니다. O
l &
n a
te r
I n
c l e
r a
O
사용자가 정의한 예외
예제:
DEFINE p_department_desc = 'Information Technology '
DEFINE P_department_number = 300
DECLARE
e_invalid_department EXCEPTION; 1
BEGIN
UPDATE departments
SET department_name = '&p_department_desc'
WHERE department_id = &p_department_number;
IF SQL%NOTFOUND THEN
RAISE e_invalid_department; 2
END IF;
COMMIT;
EXCEPTION
WHEN e_invalid_department THEN 3
DBMS_OUTPUT.PUT_LINE('No such department id.');
END;
n l y
e O
사용자가 정의한 예외 트랩(계속)
U s
사용자가 정의한 예외를 트랩하려면 이를 선언하고 명시적으로(explicitly) 발생시켜야 합니다.
1. 사용자가 정의한 예외의 이름을 선언 부분에서 선언합니다.
A I
구문:
O
exception
설명:
EXCEPTION;
exception 예외의 이름입니다.
l &
n a
2. 실행 부분에서 RAISE 문을 사용하여 예외를 명시적으로(explicitly) 발생시킵니다.
구문:
te r
n
RAISE exception;
I
설명: exception 앞에서 선언한 예외입니다.
e
l
3. 선언한 예외를 해당 예외 처리 루틴에서 참조합니다.
c
예제
r a
이 블록은 부서 설명을 갱신합니다. 사용자가 부서 번호와 새 이름을 제공하는데, 존재하지
O
않는 부서 번호를 입력하면 DEPARTMENT 테이블의 행(row)이 갱신되지 않고 예외가 발생하여
유효하지 않은 부서 번호가 입력되었다는 메시지를 출력합니다.
참고: 호출 환경에 동일한 예외를 다시 발생시키려면 예외 처리기 내에 RAISE 문만
사용합니다.

호출 환경
iSQL*Plus 오류 번호와 메시지를 화면에

표시합니다.
Procedure Builder 오류 번호와 메시지를 화면에 표시합니
다.
Oracle Developer ERROR_CODE 및 ERROR_TEXT 패키지 함
Forms 수를 통해 트리거에서 오류 번호 및 메시
지를 액세스합니다.
선행 컴파일러 응용 SQLCA 데이터 구조를 통해 예외 번호를
프로그램 액세스합니다.
상위 PL/SQL 블록 상위 블록의 예외 처리 루틴에서 예외를
트랩합니다.
n l y
e O
예외 전달
PL/SQL 블록 안에서 예외를 트랩하는 것이 아니라 호출 환경에서 예외를 처리하도록
U s
전달합니다. 각 호출 환경은 오류를 표시하고 액세스하는 고유의 방법을 가지고 있습니다.
A I
O
l &
n a
te r
I n
c l e
r a
O
예외 전달
DECLARE
. . .
e_no_rows exception;
e_integrity exception;
PRAGMA EXCEPTION_INIT (e_integrity, -2292);
BEGIN
FOR c_record IN emp_cursor LOOP
BEGIN
서브 블록에서 예외를 SELECT ...
UPDATE ...
처리하거나 상위 블록에 IF SQL%NOTFOUND THEN
전달할 수 있습니다. RAISE e_no_rows;
END IF;
END;
END LOOP;
EXCEPTION
WHEN e_integrity THEN ...
WHEN e_no_rows THEN ...
END;
n l y
e O
서브 블록에서 예외 전달
서브 블록에서 예외를 처리하여 정상적으로 종료하면 서브 블록 END 문 바로 다음의 상위
U s
블록으로 제어가 넘어갑니다.
A I
그러나 PL/SQL이 예외를 발생시켰는데 현재 블록에 해당 예외에 대한 처리기가 없다면,
예외는 처리기를 찾을 때까지 다음 상위 블록으로 계속해서 전달됩니다. 예외를 처리할 수 O
있는 상위 블록이 없으면 호스트 환경에서 예외를 처리할 수 없습니다.
l &
a
예외를 상위 블록에 전달하면 해당 서브 블록에 남아 있던 실행 가능한 작업은 무시됩니다.
n
te r
이 작업 방식의 장점은 상위 블록에는 보다 범용적인 예외 처리를 지정할 수 있고 자체
블록에는 고유한 오류 처리를 필요로 하는 명령문을 포함시킬 수 있다는 점입니다.
I n
예제에서 e_no_rows와 e_integrity 예외가 외부 블록에서 선언된 것을 볼 수 있습니다.
내부 블록에서 e_no_rows 예외가 발생하면 PL/SQL은 서브 블록에서 예외를 찾습니다.
le
그런데 이 예외는 서브 블록에 선언되어 있지 않으므로 외부 블록으로 전달되고 따라서
c
PL/SQL은 외부 블록에서 해당 선언을 찾게 됩니다.
r a
O
RAISE_APPLICATION_ERROR
프로시저
구문:
raise_application_error (error_number,
message[, {TRUE | FALSE}]);
y 이 프로시저를 사용하면 내장 서브 프로그램에서

사용자가 정의한 오류 메시지를 발생시킬 수 있습니다.
y 응용 프로그램에 오류를 보고할 수 있고 처리되지 않은
예외가 반환되는 것을 방지할 수 있습니다.
n l y
e O
RAISE_APPLICATION_ERROR 프로시저
RAISE_APPLICATION_ERROR 프로시저를 사용하면 비표준 오류 코드 및 오류 메시지를
U s
반환함으로써 미리 정의된 예외를 대화식으로 교환할 수 있습니다.
RAISE_APPLICATION_ERROR를 사용하면 응용 프로그램에 오류를 보고할 수 있고 처리되지
A I
않은 예외가 반환되는 것을 방지할 수 있습니다.
O
구문 설명:
l &
error_number
n a
사용자가 예외에 지정하는 번호입니다(-20000 ~ -20999).
message
te r
사용자가 예외에 지정하는 메시지로 최대 길이 2,048바이트의
문자열입니다.
In
TRUE | FALSE 선택적 부울 파라미터이며 TRUE면 이전 오류 스택에 해당
오류가 추가되고 FALSE(기본값)면 이전의 모든 오류를 해당
c l e 오류로 대체합니다.
r a
O
프로시저
y 다음 두 부분에서 사용합니다.
− 실행 부분
− Exception 섹션
y 다른 Oracle Server 오류와 동일한 방식으로
사용자에게 오류 조건을 반환합니다.
n l y
e O
RAISE_APPLICATION_ERROR 프로시저(계속)
RAISE_APPLICATION_ERROR는 PL/SQL 프로그램의 실행 부분이나 EXCEPTION 섹션 또는
U s
두 군데 모두에서 사용할 수 있습니다. 이 경우 오류는 Oracle Server가 미리 정의된 오류, 미리
정의되지 않은 오류 또는 사용자가 정의한 오류를 발생시키는 것과 동일한 방식으로 A I
반환됩니다. 즉, 오류 번호와 오류 메시지가 사용자에게 표시됩니다.
O
l &
n a
te r
I n
c le
r a
O
실행 부분:
BEGIN
...
WHERE manager_id = v_mgr;
RAISE_APPLICATION_ERROR(-20202,
'This is not a valid manager');
END IF;
...
Exception 섹션:
...
EXCEPTION
RAISE_APPLICATION_ERROR (-20201,
'Manager is not a valid employee.');
END;
n l y
e O
예제
U s
슬라이드는 RAISE_APPLICATION_ERROR 프로시저를 PL/SQL 프로그램의 실행 부분과
EXCEPTION 섹션 모두에 사용할 수 있음을 보여주고 있습니다.
A I
다음은 RAISE_APPLICATION_ERROR 프로시저를 PL/SQL 프로그램의 실행 부분과
EXCEPTION 섹션 모두에 사용할 수 있음을 보여주는 또 다른 예제입니다. O
DECLARE
l &
e_name EXCEPTION;
n a
BEGIN
te r
PRAGMA EXCEPTION_INIT (e_name, -20999);
n
...
e I
WHERE last_name = 'Higgins';
c l
RAISE_APPLICATION_ERROR(-20999,'This is not a valid last name');
r
END IF;
a
O
EXCEPTION
WHEN e_name THEN
-- handle the error
...
END;
/

요약

배웠습니다.
y 예외 유형:
− 미리 정의된 Oracle Server 오류
− 미리 정의되지 않은 Oracle Server 오류
− 사용자가 정의한 오류
y 예외 트랩
y 예외 처리:
− PL/SQL 블록 내에서 예외를 트랩합니다.
− 예외를 전달합니다.
n l y
e O
요약
PL/SQL에서 경고 조건이나 오류 조건을 예외라고 합니다. 미리 정의된 예외는 Oracle Server에
U s
정의되어 있는 오류 조건입니다. 미리 정의되지 않은 예외는 기타 표준 Oracle Server
오류입니다. 사용자가 정의한 예외는 사용자의 응용 프로그램에만 적용되는 예외입니다. 미리 A I
정의된 예외의 예로는 0으로 나누는 예외(ZERO_DIVIDE) 또는 메모리 부족
O
정의되지 않은 예외에 이름을 지정할 수 있습니다.
l &
예외(STORAGE_ERROR) 등이 있습니다. PRAGMA EXCEPTOIN_INIT 문을 사용하면 이름이
a
PL/SQL 블록, 서브 프로그램 또는 패키지의 선언 부분에서 자신만의 예외를 정의할 수
n
te r
있습니다. 예를 들어 초과 인출된 은행 계좌에 플래그를 지정하기 위해
INSUFFICIENT_FUNDS라는 이름의 예외를 정의할 수 있습니다. 사용자가 정의한 예외에는
반드시 이름을 지정해야 합니다.
I n
오류가 발생하면 예외가 발생합니다. 즉 정상 실행이 중단되고 제어는 PL/SQL 블록이나 서브
l e
프로그램의 예외 처리 부분으로 전달됩니다. 내부 예외는 런타임 시스템에 의해
c
암시적으로(implicitly) 즉, 자동으로 발생됩니다. 사용자가 정의한 예외는 RAISE 문을 사용해
r a
명시적으로(explicitly) 발생시켜야 하며 RAISE 문으로 미리 정의된 예외도 발생시킬 수
O
있습니다.
발생한 예외는 예외 처리기라고 하는 별도의 루틴을 작성하여 처리합니다. 예외 처리기가
실행되고 나면 현재 블록의 실행이 중단되고 상위 블록에 있는 그 다음 명령문을 사용하여
실행이 재개됩니다. 상위 블록이 없으면 제어는 호스트 환경으로 넘어갑니다.

연습 8 개요

y 명명된 예외 처리
y 사용자가 정의한 예외 생성 및 호출
n l y
e O
연습 8 개요
이 연습에서는 특정 상황에 대한 예외 처리기를 작성합니다.
U s
A I
O
l &
n a
te r
I n
c le
r a
O
연습 8
1. 지정한 급여를 받는 사원의 이름을 선택하는 PL/SQL 블록을 작성하십시오.
a. DEFINE 명령을 사용하여 급여를 지정하십시오.
b. iSQL*Plus 치환 변수를 통해 이 값을 PL/SQL 블록으로 전달하십시오. 입력된 급여가
두 개 이상의 행(row)을 반환하면 적절한 예외 처리기를 사용하여 예외를 처리하고
MESSAGES 테이블에 “More than one employee with a salary of <salary>.” 메시지를
삽입하십시오.
c. 입력한 급여에 대한 행이 반환되지 않으면 적절한 예외 처리기로 예외를 처리하고
MESSAGES 테이블에 “No employee with a salary of <salary>.” 메시지를 삽입하십시오.
d. 입력한 급여에 대한 행이 하나만 반환되면 MESSAGES 테이블에 해당 사원의 이름 및
급여를 삽입하십시오.
e. 나머지 다른 예외는 적합한 예외 처리기로 처리하고 MESSAGES 테이블에 “Some other
error occurred.” 메시지를 삽입하십시오.
f. 다양한 사례를 사용해 블록을 테스트합니다. MESSAGES 테이블의 행을 표시하여
PL/SQL 블록이 제대로 실행되었는지 검사하십시오. 다음은 몇 가지 예제 출력입니다.
n l y
e O
U s
2. p3q3.sql의 코드를 수정하여 예외 처리기를 추가하십시오.
A I
a. DEFINE 명령을 사용하여 부서 ID와 부서 위치를 지정한 다음 iSQL*Plus 치환 변수를
통해 이 값을 PL/SQL 블록으로 전달하십시오.
O
l &
b. 오류가 발생할 경우 지정된 부서가 존재하지 않는다는 메시지를 사용자에게 전달하는
예외 처리기를 작성하십시오. 바인드 변수를 사용하여 사용자에게 메시지를
전달하십시오.
n a
r
c. 존재하지 않는 부서를 입력하여 PL/SQL 블록을 실행해 보십시오.
te
I n
c le
r a
O
연습 8(계속)
3. iSQL*Plus 치환 변수에 설정된 급여보다 $100가 많거나 적은 범위 내에 있는 사원의 수를
출력하는 PL/SQL 블록을 작성하십시오. DEFINE 명령을 사용하여 급여 값을 지정하고
iSQL*Plus 치환 변수를 통해 이 값을 PL/SQL 블록에 전달하십시오.
a. 지정한 급여 범위 내에 해당하는 사원이 없으면 예외를 사용하여 이러한 상황을
사용자에게 알려 주는 메시지를 출력하십시오.
b. 지정한 급여 범위 내에 해당하는 사원이 한 명 이상 있으면 해당 사원 수를 알려 주는
메시지를 출력하십시오.
c. 나머지 다른 예외는 적합한 예외 처리기로 처리하고 예외가 발생했음을 알려 주는
메시지를 출력하십시오.
DEFINE p_sal = 7000
DEFINE p_sal = 2500
DEFINE p_sal = 6500
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O
프로시저 작성
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 익명 PL/SQL 블록과 명명된 PL/SQL 블록(서브
프로그램) 구분
y 서브 프로그램 설명
y 서브 프로그램 사용의 장점 나열
y 서브 프로그램을 호출할 수 있는 여러 환경 나열
n l y
e O
단원 목표
PL/SQL은 다양한 프로그램 생성자를 지원합니다. 이 단원에서는 익명 블록과 명명된 PL/SQL
U s
블록의 차이점을 설명합니다. 명명된 PL/SQL 블록을 서브 프로그램 또는 프로그램
단위라고도 합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
목표

y PL/SQL 블록과 서브 프로그램 설명
y 프로시저의 용도 설명
y 프로시저 작성
y 형식 매개변수와 실제 매개변수의 차이점 식별
y 여러 파라미터 모드의 기능 나열
y 파라미터를 사용하는 프로시저 작성
y 프로시저 호출
y 프로시저에서 예외 처리
y 프로시저 제거
n l y
e O
단원 목표
이 단원에서는 익명 PL/SQL 블록과 서브 프로그램 간의 차이점을 설명하고, 프로시저의 작성,
U s
실행 및 제거에 대해서도 살펴봅니다.
A I
O
l &
n a
te r
I n
c le
r a
O
PL/SQL 프로그램 생성자
<header> IS|AS
또는 DECLARE
BEGIN
EXCEPTION
툴 생성자 데이터베이스 서버
익명 블록 END; 생성자
응용 프로그램 프로시저 또는 익명 블록
함수 내장 프로시저 또는 함수
응용 프로그램 패키지 내장 패키지
응용 프로그램 트리거 데이터베이스 트리거
객체 유형 객체 유형
n l y
e O
PL/SQL 프로그램 생성자
슬라이드의 도표는 기본 PL/SQL 블록을 사용하는 다양한 PL/SQL 프로그램 생성자를 나타낸
U s
것입니다. 일반적으로 블록은 익명 블록이나 명명된 블록(서브 프로그램 또는 프로그램 단위)
중 하나에 속합니다.
A I
O
l &
모든 PL/SQL 생성자는 하나 이상의 블록으로 구성됩니다. 이러한 블록은 완전히 별개이거나
서로 다른 블록 안에 중첩될 수 있습니다. 따라서 한 블록이 다른 블록의 일부가 될 수 있고 이
다른 블록이 다시 전체 코드 단위의 일부가 될 수 있습니다.
n a
te r
참고: 슬라이드에서 DECLARE 키워드 앞에 있는 “또는”이라는 단어는 구문의 일부가 아니라
도표에서 서브 프로그램 시작과 익명 블록 시작을 구분하기 위한 것입니다.
I n
PL/SQL 블록은 Oracle Server에서 구성되며 Oracle Server를 사용할 수 있습니다(내장 PL/SQL
프로그램 단위). 또한 PL/SQL 블록은 Oracle Forms Developer, Oracle Report Developer 등의
l e
Oracle Developer 툴을 사용하여 구성할 수도 있습니다(응용 프로그램 또는 클라이언트측
c
PL/SQL 프로그램 단위).
r a
객체 유형은 사용자가 정의한 조합 데이터 유형으로, 데이터 구조를 데이터 조작에 필요한
O
함수 및 프로시저와 함께 캡슐화합니다. 객체 유형은 Oracle Server에서 생성하거나 Oracle
Developer 툴을 사용하여 생성할 수 있습니다.
이 과정에서는 내장 프로시저 및 함수, 데이터베이스 트리거, 패키지를 작성하고 관리하는
방법을 설명합니다. 객체 유형 생성은 이 과정에서 다루지 않습니다.
서브 프로그램 개요
서브 프로그램:
y 파라미터를 사용할 수 있고 호출 환경에서 호출할 수 있는
명명된 PL/SQL 블록입니다.
y 다음 두 가지 유형이 있습니다.
− 작업을 수행하는 프로시저
− 값을 계산하는 함수
y 표준 PL/SQL 블록 구조를 기반으로 합니다.
y 모듈화, 재사용성, 확장성 및 유지 관리 편의성을
제공합니다.
y 손쉬운 유지 관리, 향상된 데이터 보안 및 무결성, 향상된
성능, 향상된 코드 명확성을 제공합니다.
n l y
e O
서브 프로그램 개요
서브 프로그램은 선언 부분, 실행 부분, 그리고 선택 사항인 예외 처리 부분을 포함하는 표준
U s
PL/SQL 구조를 기반으로 합니다.
서브 프로그램은 컴파일하여 데이터베이스에 저장할 수 있으며 모듈화, 확장성, 재사용성 및 A I
유지 관리 편의성을 제공합니다.
O
&
모듈화는 큰 코드 블록을 모듈이라고 하는 작은 코드 그룹으로 나누는 과정입니다. 코드를
l
n a
모듈화하면 해당 모듈을 같은 프로그램에서 재사용하거나 다른 프로그램과 공유할 수
있습니다. 하나의 커다란 프로그램보다는 작은 크기의 여러 모듈 코드를 유지 관리 및
te r
디버그하는 것이 더 쉽습니다. 또한, 필요하다면 프로그램의 다른 모듈에 영향을 미치지 않고
모듈에 다른 기능을 추가해서 사용자 정의하는 방식으로 쉽게 확장할 수 있습니다.
I n
서브 프로그램이 여러 위치에서 사용될 수는 있지만 해당 서브 프로그램의 실제 코드는 한
le
위치에만 있기 때문에 서브 프로그램 수정이 필요한 경우 이 위치에서만 수정하면 되므로
유지 관리가 쉽습니다. 또한 서브 프로그램은 향상된 데이터 무결성 및 보안을 제공합니다.
c
r a
특정 데이터 객체를 서브 프로그램을 통해 액세스하도록 만든 후, 적절한 액세스 권한을 가진
사용자만 이 서브 프로그램을 호출하도록 할 수 있습니다.
O
익명 PL/SQL 블록의 블록 구조
DECLARE (선택 사항)

블록 안에서 사용될 PL/SQL 객체를 선언합니다.
BEGIN (필수 사항)
실행문을 정의합니다.
오류나 예외가 발생할 경우 수행될 작업을
정의합니다.
END; (필수 사항)
n l y
e O
익명 블록
익명 블록은 이름을 갖지 않습니다. 응용 프로그램에서 실행될 위치에 익명 블록을 선언하면
U s
실행 중에 PL/SQL 엔진에 전달되어 실행됩니다.
y 키워드 DECLARE 및 BEGIN 사이에 있는 부분을 선언 부분이라고 합니다. 선언 A I
부분에서는 변수, 상수, 커서 및 블록 내에서 참조할 사용자가 정의한 예외 등의 PL/SQL
O
사항입니다.
l &
객체를 정의합니다. PL/SQL 객체를 선언하지 않는 경우 DECLARE 키워드는 선택
y
n a
BEGIN 및 END 키워드는 필수 사항이며 수행될 작업 몸체(body)의 앞뒤에 놓입니다.
y
te r
이 부분을 블록의 실행 부분이라고 합니다.
EXCEPTION 및 END 사이의 부분은 EXCEPTION 섹션입니다. EXCEPTION 섹션에서는
I n
오류 조건을 트랩하며, 지정된 조건이 발생했을 때 수행될 작업을 정의합니다.
c l e
EXCEPTION 섹션은 선택 사항입니다.
키워드 DECLARE, BEGIN, EXCEPTION 뒤에는 세미콜론(;)을 사용하지 않지만 END 및 기타
a
모든 PL/SQL 문에는 세미콜론이 있어야 합니다.
r
O
PL/SQL 서브 프로그램의 블록 구조
<header>
서브 프로그램 명세(specification)
IS | AS
선언 부분
BEGIN
실행 부분
서브 프로그램 몸체(body)
Exception 섹션
END;
n l y
e O
서브 프로그램
서브 프로그램은 파라미터를 사용할 수 있고 호출 환경에서 호출할 수 있는 명명된 PL/SQL
U s
블록입니다. PL/SQL에는 프로시저와 함수라는 두 가지 유형의 서브 프로그램이 있습니다.
서브 프로그램 명세(specification)
A I
y 헤더는 명명된 블록에만 해당되는 것으로 프로그램 단위가 호출되는 방법을 결정합니다.
O
헤더를 통해 다음 사항을 확인할 수 있습니다.
− PL/SQL 서브 프로그램 유형(프로시저 또는 함수)
l &
− 서브 프로그램 이름
n a
−
−
파라미터 목록(있을 경우)
te r
함수에만 적용되는 RETURN 절
y
I n
IS 또는 AS 키워드는 필수 사항입니다.
서브 프로그램 몸체(body)
c l e
y IS|AS와 BEGIN 사이에 있는 블록의 선언 부분입니다. 익명 블록에서 선언 부분의 시작을
y r a
지정하는 데 사용되는 DECLARE 키워드를 여기에서는 사용하지 않습니다.
BEGIN 및 END 키워드 사이의 실행 부분은 필수 사항이며 수행할 작업 몸체(body)의
O 앞뒤에 놓입니다. 이 부분에는 하나 이상의 명령문이 있어야 합니다. 실행문으로 간주되는
NULL; 문이라도 하나 있어야 합니다.
y EXCEPTION 및 END 사이의 EXCEPTION 섹션은 선택 사항이며 미리 정의된 오류 조건을
트랩합니다. 이 부분에서는 지정된 오류 조건이 발생한 경우 수행될 작업을 지정합니다.
PL/SQL 서브 프로그램
----- --- --- ---

-----xxx
---xxx
---xxx
--- ----- --- --- ---
xxx xxx xxx ----- --- --- ---
----- --- --- --- P
----- --- --- --- ----- --- --- ---
----- --- --- --- ----- --- --- ---
xxx xxx xxx xxx xxx xxx ----- --- --- ---
xxx xxx xxx xxx xxx xxx
----- --- --- --- P
----- --- --- --- ----- --- --- ---
xxx xxx xxx 반복되는 코드가 ----- --- --- ---
xxx xxx xxx 들어 있는 P
----- --- --- --- 서브 프로그램 P ----- --- --- ---
----- --- --- ---
----- --- --- ---
여러 위치에서 서브 프로그램을
PL/SQL 프로그램에서 호출하는 PL/SQL 프로그램
한 번 이상 반복되는 코드
n l y
e O
서브 프로그램
슬라이드의 도표는 PL/SQL 블록에서 반복되는 일련의 PL/SQL 문을 서브 프로그램으로 대체하는
U s
방법을 보여줍니다.
PL/SQL 서브 프로그램에서 일련의 명령문이 한 번 이상 반복되는 경우에는 해당 반복 코드로 서브 A I
프로그램을 작성한 후 PL/SQL 블록의 여러 위치에서 호출할 수 있습니다. 서브 프로그램을
O
호출할 수 있습니다.
l &
작성하여 데이터베이스에 저장하고 나면 여러 응용 프로그램에서 몇 번이든 이 서브 프로그램을
n a
te r
I n
c l e
r a
O
y 성능 향상
n l y
9-9
e O
내장 프로시저 및 함수를 사용하면 응용 프로그램 개발을 모듈화할 수 있다는 점 외에도 많은
장점이 있습니다.
U s
− 다른 사용자를 방해하지 않고 온라인으로 루틴을 수정합니다. A I
− 루틴 하나를 수정하여 여러 응용 프로그램에 영향을 줍니다. O
− 루틴 하나를 수정하여 중복 테스트를 제거합니다.
l &
n a
− 보안 권한을 통해 권한이 없는 사용자의 데이터베이스 객체에 대한 간접
액세스를 제어합니다.
te r
− 관련 테이블에 대한 작업이 단일 경로로 수행되도록 한 곳에 모아둠으로써 관련
I n
작업이 한꺼번에 수행되거나 수행되지 않도록 합니다.
y 성능 향상
c le
− 공유 SQL 영역을 활용하므로 여러 사용자의 구문을 매번 재분석하지 않아도
r a
됩니다.
− PL/SQL의 구문을 컴파일 중에 분석하므로 실행 중에 구문을 분석하지 않아도
O 됩니다.
− 여러 명령을 묶음으로써 데이터베이스에 대한 호출 수를 줄이고 네트워크
통신량을 감소시킵니다.
y 코드 명확성 향상: 루틴의 작업을 기술하는 적절한 식별자 이름을 사용함으로써 주석
사용의 필요성을 줄이고 코드 명확성을 향상시킵니다.
iSQL*Plus를 사용하여
서브 프로그램 개발
2 3
n l y
iSQL*Plus를 사용하여 서브 프로그램 개발

e O
iSQL*Plus는 SQL*Plus에 대한 인터넷 가능 인터페이스이며, 웹 브라우저로 오라클
U s
데이터베이스에 연결하여 다른 SQL*Plus 인터페이스를 사용하는 것처럼 작업을 수행할 수
있습니다.
A I
1. 텍스트 편집기를 사용하여 서브 프로그램을 정의하는 SQL 스크립트를 작성합니다.
슬라이드의 예제는 파라미터 없이 LOG_EXECUTION 내장 프로시저를 작성합니다. 이 O
l &
프로시저는 사용자 이름과 현재 날짜를 LOG_TABLE이라는 데이터베이스 테이블에
기록합니다.
n a
te r
iSQL*Plus 브라우저 창에서 다음을 수행합니다.
2. Browse 버튼을 사용하여 SQL 스크립트 파일을 찾습니다.
I n
3. Load Script 버튼을 사용하여 스크립트를 iSQL*Plus 버퍼로 로드합니다.
표시됩니다.
c le
4. Execute 버튼을 사용하여 코드를 실행합니다. 기본적으로 코드의 출력은 화면에
r a
PL/SQL 서브 프로그램은 Oracle Forms Developer 등과 같은 오라클 개발 툴로도 작성할 수
있습니다.
O
내장 프로시저 및 함수 호출
Scott LOG_EXECUTION
프로시저
1 xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
2
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
3 vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
xxxxxxxxxxxxxx vvvvvvvvvvvvvv
Oracle Oracle Oracle vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
Portal Discoverer Forms vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
Developer vvvvvvvvvvvvvv
xxxxxxxxxxxxxx
vvvvvvvvvvvvvv
4
Scott
n l y
9-11
내장 프로시저 및 함수 호출 방법
e O
이전에 작성한 프로시저나 함수를 iSQL*Plus, Oracle Forms Developer, Oracle Discoverer,
U s
Oracle Portal, 기타 내장 프로시저, 여러 오라클 툴 및 선행 컴파일러 응용 프로그램 등과
같은 다양한 환경에서 호출할 수 있습니다. 다음 표에서는 이전에 작성한 프로시저인
log_execution을 다양한 환경에서 호출하는 방법을 설명합니다. A I
iSQL*Plus O
Oracle Forms Developer와
l
log_execution;&
EXECUTE log_execution
같은 오라클 개발 툴
n a
다른 프로시저
te rCREATE OR REPLACE PROCEDURE leave_emp

(p_id IN employees.employee_id%TYPE)
I n IS
e
BEGIN
cl
r a WHERE employee_id = p_id;

log_execution;
O END
leave_emp;

프로시저란?
y 프로시저는 작업을 수행하는 일종의 서브

프로그램입니다.
y 프로시저는 반복 실행을 위해 데이터베이스에 스키마
객체로 저장될 수 있습니다.
n l y
e O
프로시저 정의
프로시저는 파라미터(인수라고도 함)를 사용할 수 있고 사용자가 호출할 수 있는 명명된
U s
PL/SQL 블록이며 대개 어떤 작업을 수행하기 위해 프로시저를 사용합니다. 프로시저는 헤더,
선언 부분, 실행 부분 그리고 선택 사항인 예외 처리 부분으로 구성됩니다.
A I
프로시저를 컴파일하여 데이터베이스에 스키마 객체로 저장할 수 있습니다.
O
&
프로시저를 사용하면 재사용성 및 유지 관리 편의성을 향상시킬 수 있습니다. 검증된
l
프로시저만 갱신하면 됩니다.
n a
프로시저는 여러 응용 프로그램에 사용될 수 있으며, 요구 사항이 변경된 경우에는 해당
te r
I n
c le
r a
O
프로시저 작성 구문
CREATE [OR REPLACE] PROCEDURE procedure_name
[(parameter1 [mode1] datatype1,
parameter2 [mode2] datatype2,
. . .)]
IS|AS
PL/SQL Block;
• REPLACE 옵션은 기존 프로시저를 삭제하고 해당

명령문에 의해 작성된 새 버전으로 바꿉니다.
• PL/SQL 블록은 BEGIN 또는 지역 변수 선언으로
시작하여 END 또는 END procedure_name으로
끝납니다.
n l y
9-13
프로시저 작성 구문
e O
구문 정의
파라미터 설명
U s
procedure_name
parameter
프로시저 이름입니다.
PL/SQL 변수의 이름입니다. mode 지정에 따라 이 값이 호출 환경에
A I
전달되기도 하고 호출 환경에서 이 값을 채우기도 하며 두 가지가 모두
수행되기도 합니다. O
mode 인수 유형입니다.
IN (기본값)
l &
OUT
n a
r
IN OUT
인수의 데이터 유형입니다. 모든 SQL/PLSQL 데이터 유형을 사용할 수
te
Data type
있으며 %TYPE, %ROWTYPE 또는 모든 스칼라 및 조합 데이터 유형이
PL/SQL block
I n
가능합니다.
프로시저가 수행할 작업을 정의하는 프로시저 몸체(body)입니다.
l e
CREATE PROCEDURE 문을 사용하여 새 프로시저를 작성하는 데 여기서는 파라미터 목록을
c
선언할 수 있고 표준 PL/SQL 블록이 수행할 작업을 정의해야 합니다. CREATE 절을 사용하면
r a
오라클 데이터베이스에 저장되는 독립형 프로시저를 작성할 수 있습니다.
y PL/SQL 블록은 BEGIN 또는 지역 변수 선언으로 시작하여 END 또는 END
O procedure_name으로 끝납니다. 내장 프로시저의 PL/SQL 블록에서는 호스트 변수
또는 바인드 변수를 참조할 수 없습니다.
y REPLACE 옵션은 기존 프로시저가 있을 경우 이를 삭제하고 해당 명령문에 의해 작성된
새 버전으로 바꿉니다.
y 파라미터의 데이터 유형 크기는 제한할 수 없습니다.
프로시저 개발
편집기
프로시저 1 file.sql
작성 코드
iSQL*Plus
2 file.sql 로드 및 실행
오라클 소스 코드
SHOW ERRORS를
컴파일
사용하여 컴파일
오류 확인
P 코드 작성된
프로시저
실행 3
n l y
9-14
프로시저 개발
e O
다음은 내장 프로시저 개발을 위한 주요 단계입니다. 프로시저 작성에 대한 자세한 내용은 다음 두
페이지에서 설명합니다.
U s
1. 구문 작성: 시스템 편집기 또는 워드프로세서에서 프로시저 작성 코드(CREATE PROCEDURE
문)를 입력하고 SQL 스크립트 파일(확장자 .sql)로 저장합니다.
A I
2. 코드 컴파일: iSQL*Plus로 SQL 스크립트 파일을 로드하여 실행합니다. 소스 코드가 p 코드로
O
컴파일되고 프로시저가 작성됩니다.
l &
CREATE PROCEDURE (또는 CREATE OR REPLACE PROCEDURE) 문이 있는 스크립트
a
파일에서는 컴파일 오류나 런타임 오류가 있는 명령문을 변경할 수 있고 이후에도 변경이
n
te r
가능합니다. 컴파일 오류 또는 런타임 오류가 있는 프로시저는 호출할 수 없으므로
iSQL*Plus에서 SHOW ERRORS를 사용하여 컴파일 오류를 확인합니다. CREATE PROCEDURE
문을 실행하면 프로시저에 컴파일 오류가 있을지라도 소스 코드가 데이터 딕셔너리에
I n
저장됩니다. 편집기를 사용하여 코드의 오류를 수정한 후 재컴파일하십시오.
e
3. 프로시저를 실행하여 원하는 작업을 수행합니다. 소스 코드가 컴파일되어 프로시저가
l
성공적으로 작성되면 iSQL*Plus에서 EXECUTE 명령을 사용해 프로시저를 몇 번이든 실행할 수
c
있습니다. PL/SQL 컴파일러는 구문 분석된 코드를 기반으로 의사 코드(p 코드)를 생성합니다.
r a
프로시저를 호출하면 PL/SQL 엔진이 이 p 코드를 실행합니다.
O
참고: 컴파일 오류가 있어서 CREATE PROCEDURE 문을 변경하려는 경우에는 먼저 해당 프로시저를
삭제(DROP)하거나 OR REPLACE 구문을 사용해야 합니다.
오라클 통합 개발 환경(IDE)의 Oracle Forms 및 Oracle Reports 등과 같은 툴을 사용하여 클라이언트측
응용 프로그램에 사용되는 클라이언트측 프로시저를 작성할 수 있습니다. Oracle Procedure Builder
툴을 사용하여 클라이언트측 서브 프로그램을 작성하는 방법은 부록 C를 참조하십시오.
형식 매개변수와 실제 매개변수
y 형식 매개변수: 서브 프로그램 명세(specification)의

파라미터 목록에 선언된 변수
예제:
CREATE PROCEDURE raise_sal(p_id NUMBER, p_amount NUMBER)
...
END raise_sal;
y 실제 매개변수: 서브 프로그램 호출의 파라미터 목록에서

참조되는 변수 또는 표현식
예제:
raise_sal(v_id, 2000)
n l y
e O
형식 매개변수와 실제 매개변수
형식 매개변수는 서브 프로그램 명세(specification)의 파라미터 목록에 선언된 변수입니다.
U s
예를 들어 RAISE_SAL 프로시저에서 변수 P_ID 및 P_AMOUNT가 형식 매개변수입니다.
실제 매개변수는 서브 프로그램 호출의 파라미터 목록에서 참조되는 변수 또는 표현식입니다. A I
예를 들어 RAISE_SAL 프로시저에 대한 호출 raise_sal(v_id, 2000)에서 변수 V_ID 및
O
2000이 실제 매개변수입니다.
l &
y
a
서브 프로그램 호출 시 실제 매개변수가 평가되어 그 결과가 형식 매개변수에
할당됩니다.
n
y
te r
실제 매개변수는 다음과 같은 표현식이 될 수도 있습니다.
y I n
raise_sal(v_id, raise+100);
형식 매개변수와 실제 매개변수에 서로 다른 이름을 사용하는 것이 좋습니다.
l e
이 과정에서는 형식 매개변수에 p_를 접두어로 붙입니다.
c
y
r a
형식 매개변수와 실제 매개변수의 데이터 유형은 호환되어야 합니다. 필요한 경우
PL/SQL은 값을 할당하기 전에 실제 매개변수 값의 데이터 유형을 형식 매개변수 값의
O 데이터 유형으로 변환합니다.

프로시저 파라미터 모드
프로시저
IN 파라미터
호출 환경 OUT 파라미터
IN OUT 파라미터
(DECLARE)
BEGIN
EXCEPTION
END;
n l y
e O
프로시저 파라미터 모드
파라미터를 통해 호출 환경과 값을 주고 받을 수 있습니다. 각 파라미터에 대해 IN, OUT 또는
U s
IN OUT 모드 중 하나를 선택합니다.
IN 파라미터 값을 변경하면 오류가 발생합니다. A I
O
참고: DATATYPE은 %TYPE 정의, %ROWTYPE 정의 또는 크기를 지정하지 않은 명시적(explicit)
데이터 유형이어야 합니다.
l &
파라미터 유형 설명
n a
IN (기본값)
te r
상수 값을 호출 환경에서 프로시저로 전달합니다.
OUT
IN OUT I n
값을 프로시저에서 호출 환경으로 전달합니다.
동일한 파라미터를 사용하여 호출 환경에서 프로시저로 값을
c le 전달하고 프로시저에서 호출 환경으로 다른 값을 전달할 수

있습니다.
r a
O
파라미터를 사용하여 프로시저 작성
IN OUT IN OUT
기본 모드 지정해야 함 지정해야 함
값을 서브 프로그램에 값을 호출 값을 서브
전달함 환경으로 반환함 프로그램에 전달하고
호출 환경으로
반환함
형식 매개변수가 상수로 초기화되지 않은 초기화된 변수
동작 변수
실제 매개변수는 리터럴, 변수여야 함 변수여야 함
표현식, 상수 또는 초기화된
변수임
기본값을 할당할 수 있음 기본값을 할당할 기본값을 할당할 수

수 없음 없음
n l y
e O
파라미터를 사용하여 프로시저 작성
프로시저를 작성할 때 형식 매개변수는 PL/SQL 블록의 실행 부분에 사용되는 값을 정의하고
U s
실제 매개변수는 프로시저를 호출할 때 참조됩니다.
IN 파라미터 모드는 기본 파라미터 모드입니다. 즉 파라미터에 모드를 지정하지 않으면 IN A I
파라미터로 간주됩니다. OUT 및 IN OUT 파라미터 모드의 경우에는 해당 파라미터 앞에서
O
명시적으로(explicitly) 모드를 지정해야 합니다.
l &
IN 파라미터를 수정할 수 없습니다.
n a
IN 모드의 형식 매개변수에는 값을 할당할 수 없습니다. 즉, 프로시저의 몸체(body)에서
te r
OUT 또는 IN OUT 파라미터에는 호출 환경으로 반환하기 전에 값을 할당해야 합니다.
I n
IN 파라미터에는 파라미터 목록에서 기본값을 할당할 수 있습니다. OUT 및 IN OUT
파라미터에는 기본값을 할당할 수 없습니다.
le
기본적으로 IN 파라미터는 참조에 의해 전달되며 OUT 및 IN OUT 파라미터는 값에 의해
c
전달됩니다. OUT 및 IN OUT 파라미터의 성능을 향상시키려면 컴파일러 힌트인 NOCOPY를
r a
사용하여 참조에 의한 전달을 요청합니다. NOCOPY 사용에 대해서는 Advanced PL/SQL
과정에서 자세히 설명합니다.
O
IN 파라미터: 예제
176 p_id
CREATE OR REPLACE PROCEDURE raise_salary

IS
BEGIN
UPDATE employees
SET salary = salary * 1.10
END raise_salary;
/
n l y
e O
IN 파라미터: 예제
슬라이드의 예제는 IN 파라미터가 하나 있는 프로시저를 나타낸 것입니다. iSQL*Plus에서 이
U s
명령문을 실행하면 RAISE_SALARY 프로시저가 작성되고 이 프로시저를 호출하면
RAISE_SALARY가 사원 ID에 해당하는 파라미터를 받아 10% 인상된 급여로 사원의 레코드를
A I
갱신합니다.
O
iSQL*Plus에서 프로시저를 호출하려면 EXECUTE 명령을 사용하십시오.
l &
EXECUTE raise_salary (176)
n a
te r
다른 프로시저에서 프로시저를 호출하려면 직접 호출을 사용합니다. 새 프로시저를 호출하는
위치에 프로시저 이름 및 실제 매개변수를 입력합니다.
I n
raise_salary (176);
IN 파라미터는 호출 환경에서 프로시저에 상수로 전달되므로 IN 파라미터의 값을 변경하면
오류가 발생합니다.
c l e
r a
O
OUT 파라미터: 예제
호출 환경 QUERY_EMP 프로시저
171 p_id
SMITH p_name
7400 p_salary
0.15 p_comm
n l y
e O
이 예제에서는 OUT 파라미터를 사용하는 프로시저를 작성하여 사원에 대한 정보를
U s
검색합니다. 이 프로시저는 사원 ID로 171의 값을 받아 ID가 171인 사원의 이름, 급여 및
커미션 비율을 검색하여 세 개의 OUT 파라미터에 넣습니다. QUERY_EMP 프로시저 작성
A I
코드는 다음 슬라이드에 있습니다.
O
l &
n a
te r
I n
c le
r a
O
emp_query.sql
CREATE OR REPLACE PROCEDURE query_emp
(p_id IN employees.employee_id%TYPE,
p_name OUT employees.last_name%TYPE,
p_salary OUT employees.salary%TYPE,
p_comm OUT employees.commission_pct%TYPE)
IS
BEGIN
SELECT last_name, salary, commission_pct
INTO p_name, p_salary, p_comm
FROM employees
END query_emp;
/
n l y
e O
OUT 파라미터: 예제(계속)
슬라이드의 스크립트 파일을 실행하여 QUERY_EMP 프로시저를 작성합니다. 이 프로시저에는
U s
네 개의 형식 매개변수가 있는데 그 중 세 개는 호출 환경에 값을 반환하는 OUT
파라미터입니다.
A I
이 프로시저는 P_ID 파라미터에 대한 값으로 EMPLOYEE_ID를 받습니다. 사원 ID에 해당하는
O
환경으로 반환됩니다.
l &
이름, 급여 및 커미션 비율 값이 검색되어 세 개의 OUT 파라미터에 할당되며 이 값은 호출
n a
스크립트 파일은 클라이언트측에 있고 프로시저는 데이터베이스 스키마에 저장되므로
r
스크립트 파일 이름과 프로시저 이름은 같지 않아도 됩니다.
te
I n
c l e
r a
O
OUT 파라미터 보기
• emp_query.sql 스크립트 파일을 로드 및 실행하여
QUERY_EMP 프로시저를 작성합니다.
• 호스트 변수를 선언하고 QUERY_EMP 프로시저를 실행한
후 전역 변수 G_NAME의 값을 출력합니다.
VARIABLE g_name VARCHAR2(25)

VARIABLE g_sal NUMBER
VARIABLE g_comm NUMBER
EXECUTE query_emp(171, :g_name, :g_sal, :g_comm)
PRINT g_name
n l y
e O
iSQL*Plus를 사용한 OUT 파라미터 값 확인 방법
1. SQL 스크립트 파일을 실행하고 소스 코드를 컴파일합니다.
U s
2. iSQL*Plus에서 VARIABLE 명령을 사용하여 호스트 변수를 생성합니다.
A I
3. 생성된 호스트 변수를 OUT 파라미터로 지정하여 QUERY_EMP 프로시저를 호출합니다.
EXECUTE 명령에서 호스트 변수를 참조하려면 콜론(:)을 사용합니다. O
l
4. 프로시저에서 호출 환경으로 전달된 값을 보려면 PRINT 명령을 사용합니다. &
a
슬라이드의 예제는 호출 환경에 다시 전달된 G_NAME 변수의 값을 보여줍니다. 다른 변수도
n
te r
위의 예제와 같이 개별적으로 보거나 아래처럼 PRINT 명령을 사용하여 볼 수 있습니다.
PRINT g_name g_sal g_comm
I n
VARIABLE 명령을 사용할 때 데이터 유형이 NUMBER인 호스트 변수에는 크기를 지정하지
le
마십시오. 데이터 유형이 CHAR 또는 VARCHAR2인 호스트 변수는 값을 괄호로 묶지 않으면
기본적으로 길이가 1로 지정됩니다.
c
a
PRINT 및 VARIABLE는 iSQL*Plus 명령입니다.
r
O
참고: OUT 변수에 상수 또는 표현식을 실제 매개변수로 할당하면 컴파일 오류가 발생합니다.
예를 들어 다음 명령문을 사용하면 컴파일 오류가 발생합니다.
EXECUTE query_emp(171, :g_name, raise+100, :g_comm)

IN OUT 파라미터
호출 환경 FORMAT_PHONE 프로시저
'8006330575' '(800)633-0575' p_phone_no
CREATE OR REPLACE PROCEDURE format_phone

(p_phone_no IN OUT VARCHAR2)
IS
BEGIN
p_phone_no := '(' || SUBSTR(p_phone_no,1,3) ||
')' || SUBSTR(p_phone_no,4,3) ||
'-' || SUBSTR(p_phone_no,7);
END format_phone;
/
n l y
e O
IN OUT 파라미터 사용
IN OUT 파라미터를 사용하면 값을 프로시저에 전달하고 호출 환경으로 반환할 수 있습니다.
U s
이 때 반환되는 값은 변경되지 않은 원래 값일 수도 있고 프로시저에서 설정된 새로운 값일
수도 있습니다.
A I
IN OUT 파라미터는 초기화된 변수로 동작합니다.
O
예제
l &
a
10자리 문자열을 받아서 (800) 633-0575 형식의 전화번호를 반환하는 프로시저를 IN OUT
n
파라미터를 사용하여 작성합니다.
te r
명령문을 실행하여 FORMAT_PHONE 프로시저를 작성합니다.
I n
c le
r a
O
IN OUT 파라미터 보기
VARIABLE g_phone_no VARCHAR2(15)

BEGIN
:g_phone_no := '8006330575';
END;
/
PRINT g_phone_no
EXECUTE format_phone (:g_phone_no)
PRINT g_phone_no
n l y
e O
iSQL*Plus를 사용한 IN OUT 파라미터 확인 방법
1. VARIABLE 명령을 사용하여 호스트 변수를 생성합니다.
U s
2. 익명 PL/SQL 블록을 사용하여 호스트 변수에 값을 채웁니다.
A I
3. 호스트 변수를 IN OUT 파라미터로 사용하여 FORMAT_PHONE 프로시저를 호출합니다.
EXECUTE 명령에서 호스트 변수를 참조하려면 콜론(:)을 사용합니다. O
4. 호출 환경으로 다시 전달된 값을 보려면 PRINT 명령을 사용합니다.
l &
n a
te r
I n
c l e
r a
O
파라미터 전달 방식
y 위치 적용 방식: 실제 매개변수를 형식 매개변수와

동일한 순서로 나열합니다.
y 이름 지정 방식: 실제 매개변수를 해당 형식 매개변수와
각각 연결시켜 임의의 순서로 나열합니다.
y 조합 방식: 실제 매개변수의 일부는 위치 적용 방식으로
일부는 이름 지정 방식으로 나열합니다.
n l y
e O
파라미터 전달 방식
파라미터가 여러 개인 프로시저에서는 다음과 같은 방식으로 파라미터 값을 지정할 수
U s
있습니다.
A I
방식 설명
O
위치 적용 방식 파라미터 선언 순서에 따라 값을 나열합니다.
l &
이름 지정 방식
a
특수 구문(=>)을 사용하여 각 값과 파라미터 이름을 연결시켜
n
임의 순서로 값을 나열합니다.
조합 방식
te r
앞의 값은 위치적 방식으로 나열하고 나머지 값은 이름 지정
방식의 특수 구문을 사용하여 나열합니다.
I n
c le
r a
O
파라미터의 DEFAULT 옵션
CREATE OR REPLACE PROCEDURE add_dept

(p_name IN departments.department_name%TYPE
DEFAULT 'unknown',
p_loc IN departments.location_id%TYPE
DEFAULT 1700)
IS
BEGIN
INSERT INTO departments(department_id,
department_name, location_id)
VALUES (departments_seq.NEXTVAL, p_name, p_loc);
END add_dept;
/
n l y
e O
파라미터의 기본값 예제
IN 파라미터는 기본값으로 초기화할 수 있습니다. 이를 통해 필요에 따라 기본값을
U s
사용하거나 무효화하면서 서브 프로그램에 서로 다른 개수의 실제 매개변수를 전달할 수
있습니다. 또한 서브 프로그램에 대한 모든 호출을 변경하지 않고도 새로운 형식 매개변수를
A I
추가할 수 있습니다.
O
사용하여 형식 매개변수를 선언한 것을 눈여겨보십시오.
l &
슬라이드의 명령문을 실행하여 ADD_DEPT 프로시저를 작성합니다. 여기서 DEFAULT 절을
n a
기본값은 IN 모드의 파라미터에만 할당할 수 있고 OUT 및 IN OUT 파라미터에는 기본값을
발생합니다.
te r
사용할 수 없습니다. 이런 유형의 파라미터에 기본값을 전달하면 다음과 같은 컴파일 오류가
I n
PLS-00230: OUT and IN OUT formal parameters may not have default
expressions
c le
실제 매개변수를 전달하지 않으면 해당 형식 매개변수의 기본값이 사용됩니다. 위의
a
프로시저를 호출하는 다음 페이지의 예제를 살펴보십시오.
r
O
파라미터 전달 예제
BEGIN
add_dept;
add_dept ('TRAINING', 2500);
add_dept ( p_loc => 2400, p_name =>'EDUCATION');
add_dept ( p_loc => 1200) ;
END;
/
SELECT department_id, department_name, location_id
FROM departments;
n l y
e O
파라미터의 기본값 예제(계속)
슬라이드의 익명 블록은 ADD_DEPT 프로시저를 호출하는 여러 방법과 각 프로시저 호출
U s
방법의 결과를 보여줍니다.
대개의 경우 위치 적용 방식의 표기법을 사용하여 형식 매개변수의 기본값을 무효화할 수 A I
있습니다. 하지만 실제 매개변수를 생략한다고 해서 형식 매개변수가 생략되지는 않습니다.
O
&
참고: 서브 프로그램 호출에서 위치 적용 파라미터는 이름 지정 파라미터보다 앞에 있어야
l
a
합니다. 그렇지 않고 다음 예제처럼 사용할 경우 오류 메시지가 발생합니다.
n
r
EXECUTE add_dept(p_name=>'new dept', 'new location')
te
I n
c l e
r a
O
서브 프로그램 선언
leave_emp2.sql
CREATE OR REPLACE PROCEDURE leave_emp2
IS
PROCEDURE log_exec
IS
BEGIN
INSERT INTO log_table (user_id, log_date)
VALUES (USER, SYSDATE);
END log_exec;
BEGIN
log_exec;
END leave_emp2;
/
n l y
e O
서브 프로그램 선언
모든 PL/SQL 블록에서 서브 프로그램을 선언할 수 있습니다. 이것은 독립형 프로시저인
U s
LOG_EXEC를 작성하는 대신 사용할 수 있는 방법입니다. 이런 방식으로 선언한 서브
프로그램을 지역 서브 프로그램(또는 지역 모듈)이라고 합니다. 지역 서브 프로그램은 다른
A I
프로그램의 선언 부분 내에서 정의되므로 자신이 정의된 부모 블록으로 범위가 한정됩니다.
O
l &
따라서 지역 서브 프로그램을 해당 지역 서브 프로그램이 선언된 블록의 외부에서는 호출할
수 없습니다. 지역 서브 프로그램을 선언하면 코드 블록에 적절한 업무 규칙 식별자를
할당하게 되므로 코드 명확성이 향상됩니다.
n a
te r
참고: 서브 프로그램은 블록의 선언 부분에서 선언해야 하며 다른 모든 항목의 뒤에 와야
합니다. 예를 들어, 서브 프로그램을 선언한 이후이면서 프로시저의 BEGIN이 오기 전에
I n
변수를 선언하면 컴파일 오류가 발생합니다.
여러 응용 프로그램에서 해당 코드를 액세스해야 한다면 이 서브 프로그램을 패키지에 넣거나
l e
이 코드를 사용하는 독립형 서브 프로그램을 작성하십시오. 패키지는 이 과정의 뒷부분에서
설명합니다.
c
r a
O
익명 PL/SQL 블록에서 프로시저 호출
DECLARE
v_id NUMBER := 163;
BEGIN
raise_salary(v_id); --invoke procedure
COMMIT;
...
END;
익명 PL/SQL 블록에서 프로시저 호출

슬라이드의 예제와 같이 익명 PL/SQL 블록에서 RAISE_SALARY 프로시저를 호출합니다.
PL/SQL을 지원하는 모든 툴 또는 언어에서 프로시저를 호출할 수 있습니다.
iSQL*Plus에서 독립형 프로시저를 호출하는 방법은 이미 살펴보았습니다.

다른 프로시저에서 프로시저 호출
process_emps.sql
CREATE OR REPLACE PROCEDURE process_emps
IS
SELECT employee_id
FROM employees;
BEGIN
FOR emp_rec IN emp_cursor
LOOP
raise_salary(emp_rec.employee_id);
END LOOP;
COMMIT;
END process_emps;
/
n l y
e O
다른 프로시저에서 프로시저 호출
이 예제는 다른 내장 프로시저에서 프로시저를 호출하는 방법을 보여줍니다. PROCESS_EMPS
U s
내장 프로시저는 커서를 사용하여 EMPLOYEES 테이블의 모든 레코드를 처리하고 각 사원의
ID를 RAISE_SALARY 프로시저에 전달하여 회사 전체 급여를 10% 인상합니다.
A I
O
l &
n a
te r
I n
c l e
r a
O
처리된 예외
호출된 프로시저
호출 프로시저 PROCEDURE
PROC2 ...
PROCEDURE IS
PROC1 ... ...
IS BEGIN
... ... 예외 발생
BEGIN EXCEPTION
... ... 예외 처리
PROC2(arg1); END PROC2;
...
EXCEPTION 호출 프로시저로
...
END PROC1; 제어 반환
n l y
e O
처리된 예외가 호출 프로시저에 미치는 영향
다른 프로시저가 호출할 프로시저를 개발할 때에는 처리된 예외 및 처리되지 않은 예외가
U s
트랜잭션 및 호출 프로시저에 미칠 영향에 대해 알고 있어야 합니다.
호출된 프로그램에 예외가 발생하면 제어는 해당 블록의 EXCEPTION 섹션으로 넘어갑니다. A I
예외가 처리되면 블록이 종료되고 제어는 호출 프로그램으로 되돌아갑니다. 예외가 발생하기
O
전에 실행된 DML(데이터 조작어) 문은 트랜잭션의 일부로 남습니다.
l &
n a
te r
I n
c le
r a
O
처리된 예외
CREATE PROCEDURE p2_ins_dept(p_locid NUMBER) IS
v_did NUMBER(4);
BEGIN
DBMS_OUTPUT.PUT_LINE('Procedure p2_ins_dept started');
INSERT INTO departments VALUES (5, 'Dept 5', 145, p_locid);
SELECT department_id INTO v_did FROM employees
END;
CREATE PROCEDURE p1_ins_loc(p_lid NUMBER, p_city VARCHAR2)
IS
v_city VARCHAR2(30); v_dname VARCHAR2(30);
BEGIN
DBMS_OUTPUT.PUT_LINE('Main Procedure p1_ins_loc');
INSERT INTO locations (location_id, city) VALUES (p_lid, p_city);
SELECT city INTO v_city FROM locations WHERE location_id = p_lid;
DBMS_OUTPUT.PUT_LINE('Inserted city '||v_city);
DBMS_OUTPUT.PUT_LINE('Invoking the procedure p2_ins_dept ...');
p2_ins_dept(p_lid);
EXCEPTION
DBMS_OUTPUT.PUT_LINE('No such dept/loc for any employee');
END;
n l y
처리된 예외가 호출 프로시저에 미치는 영향(계속)

e O
슬라이드에는 두 가지 프로시저가 있습니다. 프로시저 P1_INS_LOC는 LOCATIONS 테이블에
새 위치(파라미터를 통해 제공 받음)를 삽입하고 프로시저 P2_INS_DEPT는 P1_INS_LOC
U s
프로시저가 삽입한 새 위치에 새 부서(부서 ID 5)를 삽입합니다. P1_INS_LOC 프로시저는
P2_INS_DEPT 프로시저를 호출합니다.
A I
P2_INS_DEPT 프로시저에는, 존재하지 않는 사원의 DEPARTMENT_ID를 선택함으로써 O
l &
NO_DATA_FOUND 예외를 발생시키는 SELECT 문이 들어 있습니다. P2_INS_DEPT
프로시저에서는 이 예외가 처리되지 않으므로 호출 프로시저인 P1_INS_LOC로 제어가
a
반환되어 예외가 처리됩니다. 예외가 처리되면 P2_INS_DEPT 프로시저의 DML은 롤백되지
n
te r
않고 P1_INS_LOC 프로시저에 대한 트랜잭션의 일부로 남게 됩니다.
다음 코드는 두 프로시저의 INSERT 문이 제대로 수행된다는 것을 보여줍니다.
I n
EXECUTE p1_ins_loc(1, 'Redwood Shores')
c le
SELECT location_id, city FROM locations
a
SELECT * FROM departments WHERE department_id = 5;
r
O
처리되지 않은 예외
호출된 프로시저
호출 프로시저
PROCEDURE
PROCEDURE PROC2 ...
PROC1 ... IS
IS ...
... BEGIN
BEGIN ... 예외 발생
... EXCEPTION
... 예외가 처리되지 않음
PROC2(arg1); END PROC2;
...
EXCEPTION
...
END PROC1; 호출 프로시저의
EXCEPTION 섹션으로
제어가 되돌아감
n l y
e O
처리되지 않은 예외가 호출 프로시저에 미치는 영향
호출된 프로시저에서 예외가 발생하면 제어는 해당 블록의 EXCEPTION 섹션으로
U s
넘어갑니다. 예외가 처리되지 않으면 블록은 종료되고 제어는 호출 프로시저의 EXCEPTION
섹션으로 넘어갑니다. 이때 PL/SQL은 서브 프로그램이 수행한 데이터베이스 작업을
A I
롤백하지 않습니다.
O
트랜잭션의 일부로 남습니다.
l &
호출 프로시저에서 예외가 처리되면 호출 프로시저와 호출된 프로시저의 모든 DML 문은
n a
호출 프로시저에서 예외가 처리되지 않으면 호출 프로시저가 종료되고 예외는 호출 환경으로
te r
전달됩니다. 호출 프로시저 및 호출된 프로시저의 모든 DML 문은 호스트 변수에 대한 모든
변경 사항과 함께 롤백됩니다. 처리되지 않은 예외의 결과는 호스트 환경에서 결정합니다.
I n
c le
r a
O
처리되지 않은 예외
CREATE PROCEDURE p2_noexcep(p_locid NUMBER) IS
v_did NUMBER(4);
BEGIN
DBMS_OUTPUT.PUT_LINE('Procedure p2_noexcep started');
INSERT INTO departments VALUES (6, 'Dept 6', 145, p_locid);
SELECT department_id INTO v_did FROM employees
END;
CREATE PROCEDURE p1_noexcep(p_lid NUMBER, p_city VARCHAR2)

IS
v_city VARCHAR2(30); v_dname VARCHAR2(30);
BEGIN
DBMS_OUTPUT.PUT_LINE(' Main Procedure p1_noexcep');
INSERT INTO locations (location_id, city) VALUES (p_lid, p_city);
SELECT city INTO v_city FROM locations WHERE location_id = p_lid;
DBMS_OUTPUT.PUT_LINE('Inserted new city '||v_city);
DBMS_OUTPUT.PUT_LINE('Invoking the procedure p2_noexcep ...');
p2_noexcep(p_lid);
END;
n l y
처리되지 않은 예외가 호출 프로시저에 미치는 영향(계속)

e O
슬라이드에는 두 가지 프로시저가 있습니다. 프로시저 P1_NOEXCEP는 LOCATIONS 테이블에
새 위치(파라미터를 통해 제공 받음)를 삽입하고 프로시저 P2_NOEXCEP는 P1_NOEXCEP
U s
프로시저를 통해 삽입된 새 위치에 새 부서(부서 ID 5)를 삽입합니다. P1_NOEXCEP 프로시저는
P2_NOEXCEP 프로시저를 호출합니다.
A I
P2_NOEXCEP 프로시저에는, 존재하지 않는 사원의 DEPARTMENT_ID를 선택함으로써
O
l &
NO_DATA_FOUND 예외를 발생시키는 SELECT 문이 들어 있습니다. P2_NOEXCEP 프로시저가
이 예외를 처리하지 않으므로 호출 프로시저인 P1_NOEXCEP로 예외가 반환되지만 여기서도
a
예외는 처리되지 않습니다. 예외가 처리되지 않으므로 P2_NOEXCEP 프로시저의 DML은
n
te r
P1_NOEXCEP 프로시저의 트랜잭션과 함께 롤백됩니다.
다음 코드는 두 프로시저의 DML 문이 제대로 수행되지 않는다는 것을 보여줍니다.
I n
EXECUTE p1_noexcep(3, 'New Delhi')
e
SELECT location_id, city FROM locations
l
c
a
SELECT * FROM departments WHERE department_id = 6;
O r
프로시저 제거
데이터베이스에서 내장 프로시저를 제거합니다.

구문:
DROP PROCEDURE procedure_name
예제:
DROP PROCEDURE raise_salary;
n l y
e O
프로시저 제거
내장 프로시저가 더 이상 필요 없으면 SQL 문을 사용해 제거할 수 있습니다.
U s
iSQL*Plus를 사용하여 서버측 프로시저를 제거하려면 SQL 명령 DROP PROCEDURE를
실행합니다. A I
보류 중인 트랜잭션을 커밋하는 DROP PROCEDURE 등과 같은 DDL(데이터 정의어) 명령을 O
실행한 후에는 롤백을 수행할 수 없습니다.
l &
n a
te r
I n
c le
r a
O
요약

배웠습니다.
y 프로시저는 작업을 수행하는 서브 프로그램입니다.
y CREATE PROCEDURE 명령을 사용하여 프로시저를
작성합니다.
y 프로시저를 컴파일하여 데이터베이스에 저장할 수
있습니다.
y 파라미터를 사용하여 호출 환경에서 프로시저로 데이터를
전달합니다.
y 파라미터 모드에는 IN, OUT 및 IN OUT이 있습니다.
n l y
e O
요약
프로시저는 지정된 작업을 수행하는 서브 프로그램입니다. 프로시저를 컴파일하여
U s
데이터베이스에 내장 프로시저로 저장할 수 있습니다. 프로시저는 파라미터를 통해 0개
이상의 값을 호출 환경으로 반환할 수 있습니다. 파라미터 모드에는 IN, OUT 및 IN OUT이
A I
있습니다.
O
l &
n a
te r
I n
c le
r a
O
요약
y 지역 서브 프로그램은 다른 프로그램의 선언 부분 내에
정의된 프로그램입니다.
y 프로시저는 PL/SQL을 지원하는 모든 툴 및 언어에서
호출할 수 있습니다.
y 처리된 예외 및 처리되지 않은 예외가 트랜잭션과 호출
프로시저에 미치는 영향을 알고 있어야 합니다.
y DROP PROCEDURE 명령을 사용해 데이터베이스에서
프로시저를 제거할 수 있습니다.
y 프로시저는 응용 프로그램의 구성 요소 역할을 할 수
있습니다.
n l y
e O
요약(계속)
다른 프로그램의 선언 부분 내에서 선언한 서브 프로그램을 로컬 서브 프로그램이라고
U s
합니다. 로컬 서브 프로그램의 범위는 해당 로컬 서브 프로그램이 정의된 프로그램
단위입니다.
A I
처리된 예외 및 처리되지 않은 예외가 트랜잭션과 호출 프로시저에 미치는 영향을 알고
O
&
있어야 합니다. 예외는 서브 프로그램의 EXCEPTION 섹션에서 처리됩니다.
l
클라이언트측 프로시저도 작성할 수 있습니다.
n a
프로시저는 수정 및 제거할 수 있으며 클라이언트측 응용 프로그램이 사용할 수 있는
te r
I n
c le
r a
O
연습 9 개요

y 내장 프로시저를 작성하여 다음을 수행합니다.
− 제공된 파라미터 값을 사용하여 테이블에 새 행(row)을
삽입합니다.
− 제공된 파라미터 값과 일치하는 테이블 행(row)의
데이터를 갱신합니다.
− 제공된 파라미터 값과 일치하는 행(row)을 테이블에서
제거합니다.
− 제공된 파라미터 값을 기반으로 테이블을 질의하고 값을
검색합니다.
y 프로시저에서 예외를 처리합니다.
y 프로시저를 컴파일하고 호출합니다.
n l y
e O
연습 9 개요
이 연습에서는 DML 및 질의 명령을 실행하는 프로시저를 작성합니다.
U s
iSQL*Plus 사용 중 컴파일 오류가 발생하면 SHOW ERRORS 명령을 사용합니다. SHOW
ERRORS 명령의 사용에 대해서는 서브 프로그램 관리 단원에서 자세히 다룹니다. A I
iSQL*Plus에서 컴파일 오류를 수정하려면 버퍼가 아닌 스크립트 원본 파일에서 오류를 수정한 O
&
다음 새 버전의 파일을 재실행하십시오. 그러면 새 버전의 프로시저가 데이터 딕셔너리에
l
저장됩니다.
n a
te r
I n
c l e
r a
O
연습 9
참고: 추가 연습 “테이블 설명 및 데이터”에서 테이블에 대한 설명과 예제 데이터를 볼 수
있습니다.
Save Script 버튼을 사용하여 서브 프로그램을 .sql 파일로 저장하십시오.
이전에 SERVEROUTPUT OFF를 설정했으면 SERVEROUTPUT ON으로 설정하십시오.
1. ADD_JOB 프로시저를 작성 및 호출하여 그 결과를 검토하십시오.
a. JOBS 테이블에 새 업무를 삽입하는 ADD_JOB이라는 프로시저를 작성하십시오.
두 개의 파라미터를 사용하여 업무 ID와 업무명을 제공하십시오.
b. 코드를 컴파일하고 업무 ID는 IT_DBA를 업무명은 Database Administrator를
사용하여 프로시저를 호출하십시오. JOBS 테이블을 질의하여 결과를 확인하십시오.
c. ST_MAN이라는 업무 ID와 Stock Manager라는 업무명을 전달하여 프로시저를

다시 호출하십시오. 어떤 결과가 발생하며 그 이유는 무엇입니까?
___________________________________________________________________
___________________________________________________________________
2. JOBS 테이블의 업무를 수정하는 UPD_JOB이라는 프로시저를 작성하십시오.
n l y
a. 업무명을 갱신하는 UPD_JOB이라는 프로시저를 작성하십시오. 두 개의 파라미터를
사용하여 업무 ID와 새 업무명을 제공하고, 갱신이 발생하지 않을 경우를 대비하여
e O
필요한 예외 처리를 포함시키십시오.
b. 코드를 컴파일한 후 프로시저를 호출하여 업무 ID IT_DBA의 업무명을 Data
U s
I
Administrator로 변경하십시오. JOBS 테이블을 질의하여 결과를 확인하십시오.
A
O
l &
n a
또한 존재하지 않는 업무를 갱신해 봄으로써 예외 처리 기능을 확인하십시오(업무
ID IT_WEB과 업무명 Web Master 사용).
3.
te r
JOBS 테이블에서 업무를 삭제하는 DEL_JOB이라는 프로시저를 작성하십시오.
I n
a. 업무를 삭제하는 DEL_JOB이라는 프로시저를 작성하십시오. 업무가 삭제되지 않을
경우를 대비하여 필요한 예외 처리를 포함시키십시오.
l e
b. 코드를 컴파일한 후 업무 ID IT_DBA를 사용하여 프로시저를 호출하십시오.
c
JOBS 테이블을 질의하여 결과를 확인하십시오.
r a
O 존재하지 않는 업무를 삭제해 봄으로써 예외 처리 기능을 확인하십시오(업무 ID
IT_WEB 사용). 프로시저의 예외 처리 부분에 지정해 둔 메시지가 출력되어야
합니다.

연습 9(계속)
4. 사원 ID를 지정하면 EMPLOYEES 테이블을 질의해서 해당 사원의 급여 및 업무 ID를
검색하는 QUERY_EMP라는 프로시저를 작성하십시오.
a. 지정된 사원 ID에 대해 SALARY 및 JOB_ID 열의 값을 반환하는 프로시저를
작성하십시오.
OUT 파라미터인 급여 및 업무 ID에 호스트 변수를 사용하십시오.
b. 코드를 컴파일한 후 프로시저를 호출하여 사원 ID가 120인 사원의 급여와 업무
ID를 표시하십시오.
c. EMPLOYEE_ID를 300으로 지정하여 프로시저를 다시 호출하면 어떤 결과가

발생하며 그 이유는 무엇입니까?
l
___________________________________________________________________
n
___________________________________________________________________
y
e O
U s
A I
O
l &
n a
te r
I n
c l e
r a
O
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
함수 작성
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 함수의 용도 설명
y 내장 함수 작성
y 함수 호출
y 함수 제거
y 프로시저와 함수 구별
n l y
e O
단원 목표
이 단원에서는 함수를 작성하고 호출하는 방법에 대해 설명합니다.
U s
A I
O
l &
n a
te r
I n
c le
r a
O
내장 함수 개요
y 함수는 값을 반환하는 명명된 PL/SQL 블록입니다.

y 함수는 반복 실행을 위해 데이터베이스에 스키마
객체로 저장될 수 있습니다.
y 표현식의 일부로 함수를 호출할 수 있습니다.
n l y
e O
내장 함수
함수는 파라미터를 사용할 수 있고 호출할 수 있는 명명된 PL/SQL 블록입니다. 일반적으로
U s
함수는 값을 계산하기 위해 사용합니다. 함수와 프로시저는 구조가 비슷하지만 함수는 호출
환경에 값을 반환해야 하는 반면 프로시저는 호출 환경에 값을 반환하지 않거나 여러 개
A I
반환할 수 있습니다. 프로시저와 마찬가지로 함수에는 헤더, 선언 부분, 실행 부분, 그리고 선택
O
적어도 하나의 RETURN 문이 있어야 합니다.
l &
사항인 예외 처리 부분이 있습니다. 함수의 헤더에는 RETURN 절이 있어야 하며 실행 부분에
a
함수는 반복 실행을 위해 데이터베이스에 스키마 객체로 저장될 수 있습니다. 데이터베이스에
n
te r
저장된 함수를 내장 함수라고 합니다. 또한 함수는 클라이언트측 응용 프로그램에서 작성할
수도 있습니다. 이 단원에서는 내장 함수의 작성에 대해 설명하며 클라이언트측 응용 프로그램
I n
작성에 대해서는 부록 C “Procedure Builder를 사용하여 프로그램 단위 작성”을 참조하십시오.
함수는 재사용성 및 유지 관리 편의성을 향상시킵니다. 검증된 함수는 여러 응용 프로그램에서
le
사용할 수 있으며, 처리 요구 사항이 변경되더라도 해당 함수만 갱신하면 됩니다.
c
r a
SQL 표현식 또는 PL/SQL 표현식의 일부로 함수를 호출할 수 있습니다. SQL 표현식에
사용되는 함수는 부작용 제어를 위한 특정 규칙을 따라야 합니다. PL/SQL 표현식에서는 함수
O
식별자가 전달 받는 파라미터에 따라 값이 변하는 변수처럼 동작합니다.

함수 작성 구문
CREATE [OR REPLACE] FUNCTION function_name

[(parameter1 [mode1] datatype1,
parameter2 [mode2] datatype2,
. . .)]
RETURN datatype
IS|AS
PL/SQL Block;
PL/SQL 블록에는 RETURN 문이 하나 이상 있어야 합니다.
n l y
10-4
함수 구문 작성
e O
함수는 값을 반환하는 PL/SQL 블록이며 CREATE FUNCTION 문을 사용하여 새 함수를
작성합니다. CREATE FUNCTION 문에서는 파라미터 목록을 선언할 수 있고 값을 하나
U s
반환해야 하며 표준 PL/SQL 블록이 수행할 작업을 정의해야 합니다.
y REPLACE 옵션은 기존 함수가 있을 경우 이를 제거하고 해당 명령문에 의해 작성된 새 A I
버전으로 바꿉니다.
O
y RETURN 데이터 유형은 크기 명세를 포함할 수 없습니다.
l &
y
a
PL/SQL 블록은 BEGIN 또는 지역 변수 선언으로 시작하여 END 또는 END
n
function_name으로 끝나며 RETURN (표현식) 문이 하나 이상 있어야 합니다. 내장
r
함수의 PL/SQL 블록에서는 호스트 변수 또는 바인드 변수를 참조할 수 없습니다.
te
구문 정의
파라미터 I n 설명
cl
function_name
e 함수 이름입니다.
ra
parameter PL/SQL 변수 이름으로, 해당 값이 함수에 전달됩니다.
mode 파라미터 유형이며 IN 파라미터만 선언해야 합니다.
O datatype
RETURN datatype
파라미터의 데이터 유형입니다.
함수가 반환해야 하는 RETURN 값의 데이터 유형입니다.
PL/SQL block 함수가 수행할 작업을 정의하는 프로시저 몸체(body)입니다.
함수 작성
편집기
함수 작성 코드
1 file.sql
iSQL*Plus
2 file.sql 로드 및 실행
오라클 소스 코드
컴파일
P 코드 작성된 함수
호출 3
n l y
e O
내장 함수 개발 방법
다음은 내장 함수 개발의 기본 단계입니다. 다음 두 페이지에서 함수 작성의 세부 사항에 대해
U s
설명합니다.
1. 구문 작성: 텍스트 편집기에 함수 작성 코드를 입력하고 SQL 스크립트 파일로 A I
저장합니다.
O
&
2. 코드 컴파일: iSQL*Plus로 SQL 스크립트 파일을 업로드하여 실행합니다. 소스 코드가
l
p 코드로 컴파일되고 함수가 작성됩니다.
3. PL/SQL 블록에서 함수를 호출합니다.
n a
값 반환
te r
y
y I n
함수의 헤더에 RETURN 절을 데이터 유형과 함께 추가합니다.
c le
실행 부분에 RETURN 문 하나를 넣습니다.
함수에 여러 개의 RETURN 문을 사용할 수는 있지만(보통 IF 문 내에) 값이 반환되고 나면 블록
r a
처리가 중지되므로 결국 RETURN 문은 하나만 실행됩니다.
참고: PL/SQL 컴파일러는 구문 분석된 코드를 기반으로 의사 코드(p 코드)를 생성합니다.
O
함수를 호출하면 PL/SQL 엔진은 이 p 코드를 실행합니다.

내장 함수 작성
1. 편집기에 CREATE FUNCTION 문의 텍스트를 입력하고

SQL 스크립트 파일로 저장합니다.
2. 스크립트 파일을 실행하여 소스 코드를 저장하고
함수를 컴파일합니다.
3. SHOW ERRORS를 사용하여 컴파일 오류를 확인합니다.
4. 컴파일이 성공적으로 완료되면 함수를 호출합니다.
n l y
e O
내장 함수 작성 방법
1. 시스템 편집기 또는 워드프로세서에서 CREATE FUNCTION 문의 텍스트를 입력하고
U s
스크립트 파일(확장자 .sql)로 저장합니다.
2. iSQL*Plus에서 스크립트 파일을 로드 및 실행하여 소스 코드를 저장하고 소스 코드를 A I
p 코드로 컴파일합니다.
O
3. SHOW ERRORS를 사용하여 컴파일 오류를 확인합니다.
l &
a
4. 코드가 성공적으로 컴파일되면 Oracle Server 환경에서 함수를 호출할 수 있습니다.
n
te r
CREATE FUNCTION 문이 있는 스크립트 파일에서는 컴파일 오류 또는 런타임 오류가 있는
명령문을 변경할 수 있으며 이후에도 변경이 가능합니다. 컴파일 오류 또는 런타임 오류가
확인합니다.
I n
있는 함수는 호출할 수 없으므로 iSQL*Plus에서 SHOW ERRORS를 사용하여 컴파일 오류를
le
CREATE FUNCTION 문을 실행하면 함수에 컴파일 오류가 있을지라도 소스 코드가 데이터
c
딕셔너리에 저장됩니다.
r a
참고: 컴파일 오류가 있어서 CREATE FUNCTION 문을 변경하려는 경우에는 먼저 해당 함수를
O
삭제하거나 OR REPLACE 구문을 사용해야 합니다.

내장 함수 작성: 예제
get_salary.sql
CREATE OR REPLACE FUNCTION get_sal
RETURN NUMBER
IS
v_salary employees.salary%TYPE :=0;
BEGIN
SELECT salary
INTO v_salary
FROM employees
RETURN v_salary;
END get_sal;
/
n l y
e O
예제
IN 파라미터 하나를 사용하여 숫자를 반환하는 함수를 작성합니다.
U s
스크립트 파일을 실행하여 GET_SAL 함수를 작성합니다. 함수는 호출 환경에 값을 반환하므로
PL/SQL 표현식의 일부로 함수를 호출합니다. A I
반환 값을 변수에 할당하고 코드의 실행 부분에 하나의 RETRUN 문을 사용하는 것이 좋습니다. O
프로그램의 EXCEPTION 섹션에도 RETRUN 문을 사용할 수 있습니다.
l &
n a
te r
I n
c le
r a
O
함수 실행
y PL/SQL 표현식의 일부로 함수를 호출합니다.

y 반환된 값을 보유할 변수를 생성합니다.
y 함수를 실행하면 RETURN 문을 통해 반환된 값이
변수에 채워집니다.
n l y
e O
함수 실행
함수에는 하나 이상의 파라미터를 사용할 수 있지만 값은 하나만 반환해야 합니다. 반환된
U s
값을 저장할 변수를 사용하여 PL/SQL 표현식의 일부로 함수를 호출합니다.
서브 프로그램에는 세 개의 파라미터 모드인 IN (기본값), OUT 및 IN OUT을 사용할 수 있지만 A I
함수에는 OUT 및 IN OUT 모드를 사용하지 마십시오. 함수의 목적은 인수(실제 매개변수)
O
l &
없이 또는 여러 개의 인수를 사용하여 하나의 값을 반환하는 것이므로 함수에서 여러 개의
값을 반환하도록 만드는 것은 좋지 않은 프로그래밍 습관입니다. 또한 함수를 작성할 때는
a
부작용으로 인해 서브 프로그램의 지역 변수가 아닌 값이 변경되는 것을 막아야 합니다. 이런
n
부작용은 이 단원의 뒷부분에서 설명합니다.
te r
I n
c le
r a
O
함수 실행: 예제
호출 환경 GET_SAL 함수
117 p_id
RETURN v_salary
1. get_salary.sql 파일을 로드 및 실행하여 함수를 작성합니다.
2 VARIABLE g_salary NUMBER
3 EXECUTE :g_salary := get_sal(117)
4 PRINT g_salary
n l y
e O
예제
iSQL*Plus에서 GET_SAL 함수 실행
U s
1. get_salary.sql 스크립트 파일을 로드 및 실행하여 내장 함수 GET_SAL을
작성합니다. A I
2. 함수 내에서 RETURN (변수) 문으로 채울 호스트 변수를 생성합니다. O
l &
3. iSQL*Plus에서 EXECUTE 명령으로 PL/SQL 표현식을 작성하여 GET_SAL 함수를
n a
호출하고 파라미터에 값(이 예제에서는 사원 ID)을 제공합니다. 함수가 반환하는 값은
호스트 변수인 G_SALARY에 보유됩니다. 호스트 변수를 참조하려면 콜론(:)을
사용합니다.
te r
I
2800달러의 월급을 받습니다.n
4. PRINT 명령을 사용하여 함수 호출 결과를 봅니다. 사원 ID가 117인 사원 Tobias는
le
함수에는 RETURN 문에 이르게 해주는 실행 경로가 적어도 하나는 있어야 합니다. 그렇지
c
않으면 실행 중에 Function returned without value 메시지가 나타납니다.
r a
O
SQL 표현식에서 사용자가 정의한 함수
사용 시 장점
y 작업이 너무 복잡하고 다루기 힘들거나 SQL로 처리할

수 없는 경우 SQL을 확장할 수 있습니다.
y 응용 프로그램에서의 데이터 필터링과는 반대로
WHERE 절에서 사용자가 정의한 함수로 데이터를
필터링하면 효과적입니다.
y 문자열을 조작할 수 있습니다.
n l y
e O
SQL 표현식에서 사용자가 정의한 함수 호출
SQL 표현식은 PL/SQL에서 사용자가 정의한 함수를 참조할 수 있으며, 내장 SQL 함수를
U s
사용할 수 있는 모든 위치에 사용자가 정의한 함수를 사용할 수 있습니다.
장점 A I
y 너무 복잡하고 다루기 힘들거나 SQL로 처리할 수 없는 계산도 수행할 수 있습니다. O
y
l &
데이터를 응용 프로그램으로 가져오는 것이 아니라 Oracle Server 내에서 복잡한 데이터
분석을 처리하므로 데이터 독립성을 높입니다.
n a
y
y
te r
응용 프로그램이 아닌 질의에서 함수를 수행하므로 질의의 효율을 높입니다.
문자열을 암호화하고 문자열에 대해 작동하는 함수를 사용함으로써 새로운 데이터
I n
유형(예: 위도와 경도)을 조작합니다.
c le
r a
O
SQL 표현식에서 함수 호출:
예제
CREATE OR REPLACE FUNCTION tax(p_value IN NUMBER)
RETURN NUMBER IS
BEGIN
RETURN (p_value * 0.08);
END tax;
/
SELECT employee_id, last_name, salary, tax(salary)
FROM employees
WHERE department_id = 100;
n l y
e O
예제
이 슬라이드는 SELECT 문에서 호출되는 tax 함수의 작성 방법을 보여줍니다. 이 함수는
U s
NUMBER 파라미터를 받아서 해당 파라미터 값에 0.08을 곱하여 세금을 반환합니다.
iSQL*Plus에서 사원 ID, 이름, 급여 및 세금을 표시하는 질의에 TAX 함수를 포함시켜 A I
호출합니다.
O
l &
n a
te r
I n
c le
r a
O
사용자가 정의한 함수의 호출 위치
y SELECT 명령의 SELECT 목록

y WHERE 및 HAVING 절의 조건
y CONNECT BY, START WITH, ORDER BY 및 GROUP
BY 절
y INSERT 명령의 VALUES 절
y UPDATE 명령의 SET 절
n l y
e O
사용자가 정의한 함수의 사용
내장 함수를 호출할 수 있는 모든 SQL 표현식에서 PL/SQL의 사용자가 정의한 함수를 호출할
U s
수 있습니다.
예제: A I
SELECT employee_id, tax(salary) O
FROM employees
WHERE tax(salary)>(SELECT MAX(tax(salary))
l &
a
FROM employees WHERE department_id = 30)
n
ORDER BY tax(salary) DESC;
te r
I n
c le
r a
…O
SQL 표현식에서 함수 호출 시
제한 사항
SQL 표현식에서 사용자가 정의한 함수를 호출하려면

함수가 다음 조건에 맞아야 합니다.
y 내장 함수여야 합니다.
y IN 파라미터만 사용해야 합니다.
y PL/SQL 전용 유형이 아니라 유효한 SQL 데이터
유형의 파라미터만 사용해야 합니다.
y PL/SQL 전용 유형이 아니라 유효한 SQL 데이터
유형을 반환해야 합니다.
n l y
10-13
SQL 표현식에서 함수 호출 시 제한 사항
e O
SQL 표현식에서 사용자가 정의한 PL/SQL 함수를 호출하려면 함수가 특정 요구 사항을
U s
만족해야 합니다.
y SQL 문에서 호출되는 PL/SQL 함수의 파라미터는 위치 적용 방식을 사용해야 하며 이름
A I
y
지정 방식은 지원되지 않습니다.
O
내장 PL/SQL 함수는 CREATE 또는 ALTER TABLE 명령의 CHECK 제약 조건 절에서 호출할
수 없고 열의 기본값 지정에 사용할 수 없습니다.
l &
y
a
SQL 문에서 함수를 호출하려면 해당 함수에 대한 EXECUTE 권한이 있거나 해당 함수를
n
y
소유해야 합니다.
te r
함수는 유효한 SQL 데이터 유형의 데이터 유형을 반환해야 하며 BOOLEAN, RECORD,
I n
TABLE 등과 같은 PL/SQL 전용 데이터 유형은 반환할 수 없습니다. 함수의 파라미터에도
같은 제한 사항이 적용됩니다.
le
참고: SQL 문에서는 내장 함수만 호출할 수 있고 내장 프로시저는 호출할 수 없습니다.
c
r a
SQL 표현식에 사용자가 정의한 PL/SQL 함수를 사용하는 것은 PL/SQL 2.1 이상에서 가능합니다.
그 이전 버전의 PL/SQL을 사용하는 툴은 이 기능을 지원하지 않습니다. Oracle9i 이전
O
버전에서는 사용자가 정의한 함수가 단일 행(row) 함수만 가능했습니다. Oracle9i부터는
사용자가 정의한 함수를 집계 함수로 정의할 수도 있습니다.
참고: SQL 표현식에서 호출되는 함수는 OUT 및 IN OUT 파라미터를 포함할 수 없습니다.
다른 함수는 이 모드를 사용하는 파라미터를 포함할 수 있지만 권장 사항은 아닙니다.
SQL 표현식에서 함수 호출 시
제한 사항
y SQL 표현식에서 호출되는 함수는 DML 문을 포함할 수
없습니다.
y 테이블 T에 대한 UPDATE/DELETE 문에서 호출되는
함수는 동일한 테이블 T에 대한 DML을 포함할 수
없습니다.
y 테이블 T에 대한 UPDATE 또는 DELETE 문에서
호출되는 함수는 동일한 테이블을 질의할 수 없습니다.
y SQL 문에서 호출되는 함수는 트랜잭션을 종료하는
명령문을 포함할 수 없습니다.
y 함수에서는 위의 제한 사항을 위반하는 서브 프로그램을
호출할 수 없습니다.
n l y
e O
부작용 제어
내장 함수를 호출하는 SQL 문을 실행하려면 Oracle Server가 해당 함수에 부작용이 있는지
U s
알아야 합니다. 부작용이 있으면 데이터베이스 테이블에 원치 않는 변경이 수행될 수 있으므로,
SQL 표현식에서 호출되는 내장 함수에는 제한 사항이 적용됩니다.
A I
제한 사항
O
y
&
SELECT 문 또는 병렬 UPDATE나 DELETE 문에서 호출되는 함수는 데이터베이스
l
y
테이블을 수정할 수 없습니다.
n a
UPDATE 또는 DELETE 문에서 호출되는 함수는 해당 명령문이 수정하는 데이터베이스
te
테이블을 질의하거나 수정할 수 없습니다. r
y
n
SELECT, INSERT, UPDATE 또는 DELETE 문에서 호출되는 함수는 SQL 트랜잭션 제어문
I
(예: COMMIT), 세션 제어문(예: SET ROLE) 또는 시스템 제어문(예: ALTER SYSTEM)을
c le
실행할 수 없습니다. 또한 DDL 문(예: CREATE) 뒤에는 자동 커밋이 수행되므로 DDL 문
역시 실행할 수 없습니다.
y
r a
함수는 위의 제한 사항 중 하나라도 위반하는 서브 프로그램을 호출할 수 없습니다.
O
SQL에서 호출 시 제한 사항
CREATE OR REPLACE FUNCTION dml_call_sql (p_sal NUMBER)
RETURN NUMBER IS
BEGIN
INSERT INTO employees(employee_id, last_name, email,
hire_date, job_id, salary)
VALUES(1, 'employee 1', 'emp1@company.com',
SYSDATE, 'SA_MAN', 1000);
RETURN (p_sal + 100);
END;
/
UPDATE employees SET salary = dml_call_sql(2000)

n l y
e O
SQL에서 함수 호출 시 제한 사항: 예제
슬라이드의 코드는 함수에 DML 문이 포함된 예제를 보여줍니다. DML_CALL_SQL 함수에는
U s
EMPLOYEES 테이블에 새 레코드를 삽입하는 DML 문이 들어 있습니다. 이 함수가 호출되는
위치는 사원 ID가 170인 사원의 급여를 이 함수에서 반환된 급여로 수정하는 UPDATE 문인데,
A I
이 UPDATE 문은 테이블이 변경 중이라는 오류를 반환합니다.
O
&
다음 예제는 EMPLOYEE 테이블의 SALARY 열을 질의하는 QUERY_CALL_SQL 함수입니다.
l
RETURN NUMBER IS
n a
CREATE OR REPLACE FUNCTION query_call_sql(a NUMBER)
s NUMBER;
BEGIN
te r
I n
SELECT salary INTO s FROM employees
le
RETURN (s + a);
END;
c
/
r a
O
앞의 함수를 다음 UPDATE 문에서 호출하면 슬라이드에 표시된 것과 비슷한 오류 메시지가
반환됩니다.
UPDATE employees SET salary = query_call_sql(100)

함수 제거
내장 함수를 제거합니다.
구문:
DROP FUNCTION function_name
예제:
DROP FUNCTION get_sal;
• 함수를 제거하면 해당 함수에 부여된 모든 권한이

취소됩니다.
• CREATE OR REPLACE 구문은 함수를 제거한 후 다시
작성하는 것과 같습니다. 이 구문을 사용하면 함수에
부여된 권한이 동일하게 유지됩니다.
n l y
e O
함수 제거
내장 함수가 더 이상 필요 없으면 iSQL*Plus에서 SQL 문을 사용하여 이를 제거할 수 있습니다.
U s
iSQL*Plus를 사용하여 내장 함수를 제거하려면 SQL 명령인 DROP FUNCTION을 실행합니다.
A I
CREATE OR REPLACE를 DROP 및 CREATE를 수행할 경우와 비교
O
l &
CREATE OR REPLACE 구문의 REPLACE 절은 함수를 제거한 후 다시 작성하는 것과 같은
역할을 합니다. CREATE OR REPLACE 구문을 사용하면 이 객체에 대해 다른 사용자에게
a
부여된 권한이 그대로 유지됩니다. 하지만 함수를 삭제(DROP)한 다음 다시 작성하면 해당
n
함수에 부여된 권한이 자동으로 모두 취소됩니다.
te r
I n
c l e
r a
O
프로시저와 함수 비교
프로시저 함수
IN 파라미터 IN 파라미터
호출 호출
환경 OUT 파라미터
환경
IN OUT 파라미터
(DECLARE) (DECLARE)
BEGIN BEGIN
EXCEPTION EXCEPTION
END; END;
n l y
e O
프로시저와 함수의 차이점
프로시저는 추후 실행할 일련의 작업을 저장할 때 작성하며 호출 환경과 0개 이상의
U s
파라미터를 주고 받을 수 있지만 값을 반환하지 않아도 됩니다.
함수는 호출 환경으로 반환해야 하는 값을 계산할 때 작성하며 호출 환경에서 받는 0개 이상의 A I
파라미터를 포함할 수 있습니다. 함수는 값을 하나만 반환해야 하며 이 값은 RETURN 문을
O
없습니다.
l &
통해 반환됩니다. SQL 문에서 사용되는 함수는 OUT 또는 IN OUT 모드 파라미터를 사용할 수
n a
te r
I n
c le
r a
O
프로시저와 함수 비교
프로시저 함수
PL/SQL 문으로 표현식의 일부로 호출합니다.
실행됩니다.
헤더에 RETURN 절을 헤더에 RETURN 절을
포함하지 않습니다. 포함해야 합니다.
값을 반환하지 않거나 값을 하나만 반환해야 합니다.
하나 이상의 값을 반환할
수 있습니다.
RETURN 문을 포함할 수 하나 이상의 RETURN 문을
있습니다. 포함해야 합니다.
n l y
e O
프로시저와 함수의 차이점(계속)
하나의 OUT 파라미터를 포함하는 프로시저는 RETURN 문을 포함하는 함수로 재작성할 수
U s
있습니다.
A I
O
l &
n a
te r
I n
c le
r a
O
내장 프로시저 및 함수의
장점
y 성능 향상
n l y
장점
e O
내장 프로시저 및 함수를 사용하면 응용 프로그램 개발을 모듈화할 수 있다는 점 외에도
다음과 같은 장점이 있습니다.
U s
y 성능 향상
− 공유 SQL 영역을 활용하므로 여러 사용자의 구문을 매번 재분석하지 않아도 A I
됩니다. O
됩니다.
l &
− PL/SQL의 구문을 컴파일 중에 분석하므로 실행 중에 구문을 분석하지 않아도
a
− 여러 명령을 묶음으로써 데이터베이스에 대한 호출 수를 줄이고 네트워크
n
y
통신량을 감소시킵니다.
손쉬운 유지 관리
te r
I n
− 다른 사용자를 방해하지 않고도 온라인으로 루틴을 수정합니다.
− 루틴 하나를 수정하여 여러 응용 프로그램에 영향을 줍니다.
y
c e
− 루틴 하나를 수정하여 중복 테스트를 제거합니다.
l
데이터 보안 및 무결성 향상
r a
− 보안 권한을 통해 권한이 없는 사용자의 데이터베이스 객체에 대한 간접 액세스를
제어합니다.
O − 관련 테이블에 대한 작업이 단일 경로로 수행되도록 한 곳에 모아둠으로써 관련
작업이 한꺼번에 수행되거나 수행되지 않도록 합니다.
y 코드 명확성 향상: 루틴의 작업을 기술하는 적절한 식별자 이름을 사용함으로써 주석
사용의 필요성을 줄이고 코드 명확성을 향상시킵니다.
요약
배웠습니다.
y 함수는 값을 반환해야 하는 명명된 PL/SQL 블록입니다.
y 함수는 CREATE FUNCTION 구문을 사용하여
작성합니다.
y 함수는 표현식의 일부로 호출합니다.
y 데이터베이스에 저장된 함수는 SQL 문에서 호출할 수
있습니다.
y 함수는 DROP FUNCTION 구문을 사용하여
데이터베이스에서 제거할 수 있습니다.
y 일반적으로, 작업을 수행할 때 프로시저를 사용하고 값을
계산할 때 함수를 사용합니다.
n l y
e O
요약
함수는 값을 반환해야 하는 PL/SQL 블록입니다. 일반적으로 값을 계산하여 반환할 때는
U s
함수를 사용하고 작업을 수행할 때는 프로시저를 사용합니다.
함수는 작성 또는 삭제할 수 있습니다. A I
함수는 표현식의 일부로 호출할 수 있습니다. O
l &
n a
te r
I n
c le
r a
O
연습 10 개요

y 내장 함수를 작성하여 다음을 수행합니다.
− 데이터베이스 테이블을 질의하여 특정 값을 반환합니다.
− SQL 문에 사용합니다.
− 지정된 파라미터 값을 사용하여 새 행(row)을
데이터베이스 테이블에 삽입합니다.
− 기본 파라미터 값을 사용하여 내장 함수를 작성합니다.
y SQL 문에서 내장 함수를 호출합니다.
y 내장 프로시저에서 내장 함수를 호출합니다.
n l y
e O
연습 10 개요
iSQL*Plus 사용 중 컴파일 오류가 발생하면 SHOW ERRORS 명령을 사용합니다.
U s
iSQL*Plus에서 컴파일 오류를 수정하려면 버퍼가 아닌 스크립트 원본 파일에서 오류를 수정한
다음 새 버전의 파일을 재실행하십시오. 그러면 새 버전의 프로그램 단위가 데이터 딕셔너리에 A I
저장됩니다. O
l &
n a
te r
I n
c l e
r a
O
연습 10
1. 업무명을 반환하는 Q_JOB 함수를 작성하여 호출하십시오.
a. 업무명을 호스트 변수로 반환하는 Q_JOB 함수를 작성하십시오.
b. 코드를 컴파일하고 G_TITLE 호스트 변수를 생성한 다음 업무 ID인 SA_REP를
사용하여 함수를 호출하십시오. 호스트 변수를 질의하여 결과를 보십시오.
2. 사원의 월급 및 커미션을 파라미터로 받아서 연봉을 반환하는 ANNUAL_COMP 함수를

작성하십시오. 이 함수는 NULL 값을 처리해야 합니다.
a. 월급 및 커미션 값을 전달 받는 ANNUAL_COMP 함수를 작성하여 호출하십시오.
전달되는 값 중 하나 또는 둘 모두가 NULL일 수 있지만 함수는 NULL이 아닌
연봉을 반환해야 합니다. 연봉은 다음과 같은 기본 수식으로 정의됩니다.
(salary*12) + (commission_pct*salary*12)
b. EMPLOYEES 테이블의 부서 번호 80을 대상으로 하는 SELECT 문에서 이 함수를
사용하십시오.
n l y
e O
… U s
A I
O
l &
n a
te r
I n
c le
r a
O
연습 10(계속)
3. 신입 사원을 EMPLOYEES 테이블에 삽입하는 NEW_EMP 프로시저를 작성하십시오. 이

프로시저에는 신입 사원에게 지정된 부서 ID가 DEPARTMENTS 테이블에 존재하는지
확인하는 VALID_DEPTID 함수 호출 기능이 있어야 합니다.
a. 지정된 부서 ID를 검증하는 VALID_DEPTID 함수를 작성하십시오. 이 함수는
BOOLEAN 값을 반환해야 합니다.
b. 사원을 EMPLOYEES 테이블에 추가하는 NEW_EMP 프로시저를 작성하십시오.
함수가 TRUE를 반환하면 EMPLOYEES 테이블에 새 행(row)을 추가하고 FALSE면
적절한 메시지를 사용하여 사용자에게 경고해야 합니다.
대부분의 파라미터에 대한 기본값을 정의하십시오. 기본 커미션은 0, 기본 급여는
1000, 기본 부서 번호는 30, 기본 업무는 SA_REP, 그리고 기본 관리자 ID는
145입니다. 사원의 ID에는 EMPLOYEES_SEQ 시퀀스를 사용하고 사원의 성, 이름,
전자 우편 주소를 지정하십시오.
c. Jane Harris라는 신입 사원을 부서 15에 추가하여 NEW_EMP 프로시저를
테스트하십시오. 다른 모든 파라미터를 기본값으로 설정하면 어떤 결과가
발생합니까?
d. Joe Harris라는 신입 사원을 부서 80에 추가하여 NEW_EMP 프로시저를
테스트하십시오. 다른 모든 파라미터를 기본값으로 설정하면 어떤 결과가
발생합니까?
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
r a
O
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
서브 프로그램 관리
n l y
e O
U s
A I
O
l &
n a
te r
I n
c le
ra
O
목표

y 시스템 권한과 객체 권한 대조
y 호출자 권한과 정의자 권한 대조
y 데이터 딕셔너리의 뷰를 식별하여 내장 객체 관리
y DBMS_OUTPUT 패키지를 사용한 서브 프로그램 디버그
방법 설명
n l y
e O
단원 목표
이 단원에서는 시스템 권한 및 객체 권한 요구 사항을 설명하고 데이터 딕셔너리를 사용하여
U s
내장 객체에 관한 정보를 얻는 방법 및 서브 프로그램을 디버그하는 방법을 설명합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
필수 권한
시스템 권한
CREATE (ANY) PROCEDURE
DBA 권한 부여
ALTER ANY PROCEDURE
DROP ANY PROCEDURE
EXECUTE ANY PROCEDURE
객체 권한
소유자 권한 부여
EXECUTE
서브 프로그램의 다른 스키마에 있는 객체를 참조 및 액세스

하려면, 롤을 통해서가 아니라 해당 객체에 대해
명시적으로(explicitly) 부여 받은 액세스 권한을 갖고 있어야
합니다.
n l y
e O
시스템 권한 및 객체 권한
시스템 권한은 80개 이상이 있습니다. GRANT ALTER ANY TABLE TO green 등과 같이
U s
CREATE 또는 ANY라는 단어를 사용하는 권한이 시스템 권한이며 시스템 권한은 SYSTEM 또는
SYS 사용자가 할당합니다.
A I
객체 권한은 스키마 내의 특정 객체에 할당된 권한이며 항상 객체 이름을 포함합니다. 예를 들어
O
Scott은 다음과 같이 자신의 EMPLOYEES 테이블을 Green이 변경할 수 있도록 권한을 할당할 수
있습니다.
l &
GRANT ALTER ON employees TO green;
n a
te r
PL/SQL 서브 프로그램을 작성하려면 CREATE PROCEDURE 시스템 권한이 있어야 하며, 이
권한이 있으면 다른 권한 없이도 PL/SQL 서브 프로그램을 변경, 삭제 또는 실행할 수 있습니다.
I n
PL/SQL 서브 프로그램이 같은 스키마에 있지 않은 객체를 참조하는 경우에는 롤을 통해서가
아니라 해당 객체에 대해 명시적으로(explicitly) 부여 받은 액세스 권한을 갖고 있어야 합니다.
le
ANY 키워드를 사용한 경우에는 사용자 자신의 서브 프로그램 및 다른 스키마의 서브
c
프로그램을 작성, 변경, 삭제 또는 실행할 수 있습니다. ANY 키워드는 CREATE PROCEDURE
r a
권한에 대해서만 선택 사항입니다.
O
해당 PL/SQL 서브 프로그램의 소유자가 아니고 EXECUTE ANY 시스템 권한이 없는 사용자가
PL/SQL 서브 프로그램을 호출하려면 EXECUTE 객체 권한을 갖고 있어야 합니다.
기본적으로 PL/SQL 서브 프로그램은 소유자의 보안 도메인에서 실행됩니다.
참고: PROCEDURE 키워드는 내장 프로시저, 함수 및 패키지에 사용합니다.
데이터에 대한 액세스 권한 부여
직접 액세스:
EMPLOYEES
GRANT SELECT Scott
ON employees
TO scott;
Grant Succeeded.
SELECT
간접 액세스:
GRANT EXECUTE Green
ON query_emp SCOTT.QUERY_EMP
TO green;
Grant Succeeded.
프로시저는 소유자의 권한으로 실행됩니다(기본값).
n l y
e O
데이터에 대한 간접 액세스 제공
EMPLOYEES 테이블이 PERSONNEL 스키마에 있고 Scott이라는 개발자와 Green이라는 일반
U s
사용자가 있다고 가정합니다. Green은 사원 레코드를 질의하는 QUERY_EMP 프로시저를
통해서만 EMPLOYEES 테이블을 액세스할 수 있는데 이 프로시저는 Scott이 작성한 것입니다.
A I
직접 액세스 O
y
&
PERSONNEL 스키마에서 Scott에게 EMPLOYEES 테이블에 대한 객체 권한을 제공합니다.
l
y
a
Scott이 EMPLOYEES 테이블을 질의하는 QUERY_EMP 프로시저를 작성합니다.
n
간접 액세스
te r
Scott은 Green에게 QUERY_EMP 프로시저에 대한 EXECUTE 객체 권한을 제공합니다.
I n
기본적으로 PL/SQL 서브 프로그램은 소유자의 보안 도메인에서 실행됩니다. 이를 정의자
le
권한이라고 합니다. EMPLOYEES에 대해 직접 권한을 갖고 있는 Scott이 QUERY_EMP라는
프로시저를 작성하였으므로 Green은 QUERY_EMP 프로시저를 사용하여 EMPLOYEES
c
a
테이블에서 정보를 검색할 수 있습니다.
r
O
호출자 권한 사용
사용자 권한으로 프로시저가 실행됩니다.
Scott EMPLOYEES
CREATE PROCEDURE query_employee
(p_id IN employees.employee_id%TYPE,
p_name OUT employees.last_name%TYPE,
p_salary OUT employees.salary%TYPE,
p_comm OUT
employees.commission_pct%TYPE)
AUTHID CURRENT_USER SCOTT.
QUERY_EMPLOYEE
IS
BEGIN
SELECT last_name, salary,
commission_pct
INTO p_name, p_salary, p_comm
FROM employees
WHERE employee_id=p_id; Green
END query_employee; EMPLOYEES
/
n l y
e O
호출자 권한
소유자가 아닌 실행자의 보안으로 프로시저가 실행되게 하려면 AUTHID CURRENT_USER를
U s
사용합니다. 이렇게 하면 프로시저는 현재 사용자의 권한 및 스키마 컨텍스트로 실행됩니다.
이전 페이지에서 설명했듯이 소유자의 보안 도메인에서 프로시저가 실행되는 것이 A I
기본이지만 소유자 권한을 사용하여 프로시저를 실행하도록 명시적으로(explicitly) O
나타내려면 AUTHID DEFINER를 사용합니다.
l &
n a
te r
I n
c le
r a
O
내장 PL/SQL 객체 관리
데이터 딕셔너리
일반 정보 소스 코드
편집기
파라미터 P 코드
디버그 정보 DESCRIBE ...

컴파일 오류
DBMS_OUTPUT
n l y
e O
내장 PL/SQL 객체 관리
U s
내장 정보
일반
설명
객체 정보입니다.
액세스 방법
A I
USER_OBJECTS 데이터 딕셔너리 뷰
소스 코드 프로시저 텍스트입니다.
O
USER_SOURCE 데이터 딕셔너리 뷰
파라미터 모드: IN/ OUT/ IN OUT,
l & iSQL*Plus: DESCRIBE 명령
데이터 유형입니다.
a
rn
P 코드 컴파일된 객체 액세스할 수 없습니다.
컴파일 오류 e
코드입니다.
t
PL/SQL 구문 오류입니다. USER_ERRORS 데이터 딕셔너리 뷰
e In iSQL*Plus: SHOW ERRORS 명령

런타임 디버그 정보
c l 사용자가 지정한 디버그

변수 및 메시지입니다.
DBMS_OUTPUT 오라클 지원 패키지
r a
O
USER_OBJECTS
열 열 설명
OBJECT_NAME 객체 이름입니다.
OBJECT_ID
객체의 내부 식별자입니다.
OBJECT_TYPE
객체 유형(예: TABLE, PROCEDURE, FUNCTION,
PACKAGE, PACKAGE BODY, TRIGGER)입니다.
CREATED
객체가 생성된 날짜입니다.
LAST_DDL_TIME
객체가 마지막으로 수정된 날짜입니다.
TIMESTAMP
객체가 마지막으로 재컴파일된 날짜 및
시간입니다.
STATUS
VALID 또는 INVALID입니다.
*간추린 열 목록
n l y
e O
USER_OBJECTS 사용
스키마의 모든 PL/SQL 내장 객체 이름을 보려면 USER_OBJECTS 데이터 딕셔너리 뷰를
U s
질의합니다.
또한 객체 소유자를 나타내는 OWNER 열이 추가된 ALL_OBJECTS 및 DBA_OBJECTS 뷰를 A I
검사합니다. O
l &
n a
te r
I n
c l e
r a
O
모든 프로시저 및 함수 나열
SELECT object_name, object_type

FROM user_objects
WHERE object_type in ('PROCEDURE','FUNCTION')
ORDER BY object_name;
n l y
e O
예제
슬라이드의 예제는 사용자가 작성한 모든 프로시저 및 함수의 이름을 표시합니다.
U s
A I
O
l &
n a
te r
I n
c le
r a
O
USER_SOURCE 데이터 딕셔너리 뷰
열 열 설명
NAME 객체 이름입니다.
TYPE 객체 유형(예: PROCEDURE, FUNCTION,

PACKAGE, PACKAGE BODY)입니다.
LINE 소스 코드의 행 번호입니다.
TEXT 소스 코드 행의 텍스트입니다.
n l y
e O
USER_SOURCE 사용
내장 프로시저 또는 함수의 텍스트를 보려면 USER_SOURCE 데이터 딕셔너리 뷰를
U s
사용합니다.
또한 객체 소유자를 나타내는 OWNER 열이 추가된 ALL_SOURCE 및 DBA_SOURCE 뷰를 A I
검사합니다. O
&
소스 파일을 사용할 수 없는 경우 iSQL*Plus를 사용하여 USER_SOURCE로부터 이를 재생성할
l
수 있습니다.
n a
te r
I n
c l e
r a
O
프로시저 및 함수 코드 표시
SELECT text
FROM user_source
WHERE name = 'QUERY_EMPLOYEE'
ORDER BY line;
n l y
e O
예제
USER_SOURCE 데이터 딕셔너리 뷰를 사용하여 QUERY_EMPLOYEE 프로시저의 전체
U s
텍스트를 표시합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
USER_ERRORS
열 열 설명
NAME 객체 이름입니다.
TYPE 객체 유형(예: PROCEDURE, FUNCTION, PACKAGE,
PACKAGE BODY, TRIGGER)입니다.
SEQUENCE 순서 지정을 위한 시퀀스 번호입니다.
LINE 오류가 발생한 소스 코드의 행 번호입니다.
POSITION 해당 행에서 오류가 발생한 위치입니다.
TEXT 오류 메시지 텍스트입니다.
n l y
e O
컴파일 오류 보기
컴파일 오류의 텍스트를 보려면 USER_ERRORS 데이터 딕셔너리 뷰 또는 SHOW ERRORS
U s
iSQL*Plus 명령을 사용하십시오.
또한 객체 소유자를 나타내는 OWNER 열이 추가된 ALL_ERRORS 및 DBA_ERRORS 뷰를 A I
검사합니다. O
l &
n a
te r
I n
c l e
r a
O
컴파일 오류 감지: 예제
CREATE OR REPLACE PROCEDURE log_execution

IS
BEGIN
INPUT INTO log_table (user_id, log_date)
-- wrong
VALUES (USER, SYSDATE);
END;
/
n l y
e O
예제
LOG_EXECUTION이라는 위의 코드가 포함된 스크립트를 실행하면 컴파일 오류가
U s
발생합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
USER_ERRORS를 사용하여 컴파일 오류 표시
SELECT line || '/' || position POS, text

FROM user_errors
WHERE name = 'LOG_EXECUTION'
ORDER BY line;
n l y
e O
USER_ERRORS를 사용하여 컴파일 오류 표시
위의 SQL 문은 컴파일 오류를 확인할 때 사용할 수 있는 USER_ERRORS 데이터 딕셔너리 뷰에
U s
대해 SELECT 문을 수행합니다.
A I
O
l &
n a
te r
I n
c le
r a
O
SHOW ERRORS를 사용하여 컴파일 오류 표시
SHOW ERRORS PROCEDURE log_execution
n l y
e O
SHOW ERRORS
SQL 프롬프트에서 인수 없이 SHOW ERRORS를 사용하면 마지막으로 컴파일한 객체의 컴파일
U s
오류가 표시됩니다.
또한 특정 프로그램 단위에 대해 이 명령을 사용할 수 있으며 구문은 다음과 같습니다. A I
SHOW ERRORS [{FUNCTION|PROCEDURE|PACKAGE|PACKAGE O
l &
BODY|TRIGGER|VIEW} [schema.]name]
n a
SHOW ERRORS 명령을 사용하면 서브 프로그램 작성에 사용된 가장 최근의 명령문이 생성한
컴파일 오류만 볼 수 있습니다. USER_ERRORS 데이터 딕셔너리 뷰는 서브 프로그램을
te r
작성하면서 생성된 이전의 모든 컴파일 오류를 저장합니다.
I n
c le
r a
O
iSQL*Plus의 DESCRIBE
DESCRIBE query_employee
DESCRIBE add_dept
DESCRIBE tax
n l y
e O
프로시저 및 함수에 대해 DESCRIBE 명령 사용
프로시저 또는 함수 및 그 파라미터 목록을 표시하려면 iSQL*Plus의 DESCRIBE 명령을
U s
사용합니다.
예제 A I
슬라이드의 예제는 QUERY_EMPLOYEE 및 ADD_DEPT 프로시저와 TAX 함수의 파라미터 O
목록을 표시합니다.
l &
a
기본값을 가진 ADD_DEPT 프로시저의 파라미터 목록을 표시할 경우 DEFAULT 열에는
n
r
기본값이 있다는 것만 표시되고 실제 값이 표시되지는 않습니다.
te
I n
c le
r a
O
PL/SQL 프로그램 단위 디버깅
y DBMS_OUTPUT 패키지:
− 버퍼에 정보 축적
− 버퍼에서 정보 검색
y 독립 프로시저 호출(예: 출력을 로그 테이블에 기록)
y DBMS_DEBUG를 사용하는 소프트웨어
− Procedure Builder
− 협력업체 디버깅 소프트웨어
n l y
e O
PL/SQL 프로그램 단위 디버깅
슬라이드는 PL/SQL 프로그램 단위의 디버깅에 사용할 수 있는 여러 패키지를 요약한
U s
것입니다.
DBMS_OUTPUT 패키지 프로시저를 사용하여 PL/SQL 블록의 값과 메시지를 출력할 수 있는데
A I
이 작업은 버퍼에 정보를 축적한 다음 그 정보를 검색하는 방식으로 수행됩니다.
DBMS_OUTPUT은 오라클 지원 패키지이며 DBMS_OUTPUT 접두사를 사용하여 이 프로시저에 O
대한 모든 참조를 자세하게 지정합니다.
DBMS_OUTPUT 패키지 사용 시 장점
l &
n a
개발자는 이 패키지를 통해 메시지 및 값을 출력 버퍼로 전송하여 함수 또는 프로시저를
te r
세밀히 추적할 수 있습니다. iSQL*Plus에서는 ENABLE 또는 DISABLE 프로시저를 사용하는
대신 SET SERVEROUTPUT ON 또는 OFF를 사용합니다.
제시되는 진단 정보
I n
y
y 루프 카운터
c l e
프로시저가 시작 또는 중단되거나 작업이 발생했음을 나타내는 메시지
y
r a
할당 전후의 변수 값
O
참고: 버퍼는 블록이 종료되어야 비워집니다.
독립 프로시저 호출을 지정하고 출력을 로그 테이블 열의 값으로 저장하여 서브 프로그램을
디버그할 수 있습니다.
Oracle Procedure Builder를 사용한 디버깅은 부록 C에서 다룹니다. Procedure Builder는
DBMS_DEBUG라는 오라클 지정 디버깅 패키지를 사용합니다.
요약
Scott USER_SOURCE
소스
코드
컴파일
컴파일 USER_ERRORS
P 코드
오류
권한
Green
n l y
e O
요약
서브 프로그램을 통해 데이터베이스 객체에 액세스하려면 해당 작업에 필요한 권한을 갖고
U s
있어야 합니다.
다양한 데이터 딕셔너리 뷰, SQL 명령, iSQL*Plus 명령 및 오라클 지원 프로시저를 이용하여 A I
개발 주기 동안 내장 프로시저 또는 함수를 관리합니다. O
데이터 딕셔너리 뷰
l &
이름 또는 명령 설명
n a
USER_SOURCE
te r
USER_OBJECTS 데이터 딕셔너리 뷰 객체에 대한 일반 정보를 제공합니다.
데이터 딕셔너리 뷰 객체의 텍스트(즉, PL/SQL 블록)를 제공합니다.
DESCRIBE
e In
iSQL*Plus 명령
데이터 딕셔너리 뷰 컴파일 오류를 보여줍니다.
객체의 선언 정보를 제공합니다.
l
USER_ERRORS
SHOW ERRORS
a c iSQL*Plus 명령 각 프로시저 또는 함수의 컴파일 오류를 보여줍니다.
r
DBMS_OUTPUT
O
오라클 지원 패키지 사용자가 지정한 디버깅을 제공하여 변수 값 및
메시지를 보여줍니다.
GRANT iSQL 명령 프로시저를 작성하는 소유자 및 이를 실행하는
사용자에게 보안 권한을 제공하여 각각의 작업을
수행하게 합니다.

요약
실행
디버그 정보
n l y
e O
요약(계속)
y 데이터 딕셔너리를 질의합니다.
U s
− USER_OBJECTS 뷰를 사용하여 모든 프로시저 및 함수를 나열합니다.
A I
− USER_SOURCE 뷰를 사용하여 특정 프로시저 또는 함수의 텍스트를 나열합니다.
O
y
y
l &
프로시저 준비: 프로시저를 재작성하고 모든 컴파일 오류를 자동으로 표시합니다.
프로시저 테스트: 입력 값을 제공하여 프로시저를 테스트하고 출력 또는 반환 값을
표시하여 프로시저 또는 함수를 테스트합니다.
n a
te r
I n
c l e
r a
O
연습 11 개요

y 프로시저의 소스 파일 재생성
y 함수의 소스 파일 재생성
n l y
e O
연습 11 개요
이 연습에서는 프로시저와 함수의 소스 코드를 재생성합니다.
U s
A I
O
l &
n a
te r
I n
c le
r a
O
연습 11
단원 10에서 작성한 NEW_EMP 프로시저 및 VALID_DEPTID 함수의 코드를 손실했다고
가정합니다. (단원 10의 연습 문제를 풀지 않았다면 해답 스크립트를 실행하여
프로시저와 함수를 생성할 수 있습니다.)
적합한 데이터 딕셔너리 뷰를 질의하는 iSQL*Plus 스풀 파일을 생성하여 코드를
재생성하십시오.
힌트:
SET -- options ON|OFF
SELECT -- statement(s) to extract the code
SET -- reset options ON|OFF
파일의 출력을 iSQL*Plus에서 .sql 파일로 스풀하려면 Output에 대해 Save 옵션을
선택하여 코드를 실행하십시오.
n
3
l y
e O
U s
2 1
A I
O
l &
n a
te r
I n
c l e
r a 4
O

Oracle Database 9i Program With PLSQL (한글판) 볼륨 I - 학생용

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Oracle Database 9i Program With PLSQL (한글판) 볼륨 I - 학생용

Uploaded by

Copyright:

Available Formats

Oracle9i: Program with PL/SQL

기술 제공자 및 Restricted Rights Legend

검토자 Use, duplication or disclosure by the Government is subject to restrictions for

O 테이블에 LOB 열 추가 15-23

DROP TRIGGER 구문 16-31

데이터베이스 변경 내용은 저장하지 n l y

Introduction to Oracle9i: SQL for

Oracle9i: Program with PL/SQL

Oracle9i: Advanced PL/SQL

Introduction to Oracle9i: SQL for

Oracle9i: Program with PL/SQL

Oracle9i: Advanced PL/SQL

te rOracle SQL and SQL*Plus: Advanced SELECT Statements

Oracle9i: Program with PL/SQL 교과 과정표 - 4

이 과정을 마치면 다음을 수행할 수 있습니다.

y PL/SQL은 SQL에 프로그래밍 언어 설계 기능을

Oracle9i: Program with PL/SQL I-5

Oracle9i: Program with PL/SQL I-6

Oracle9i: Program with PL/SQL I-7

Oracle9i: Program with PL/SQL I-8

y 절차적 언어 제어 구조로 프로그래밍할 수 있습니다.

log_execution을 다양한 환경에서 호출하는 방법을 설명합니다. O

Oracle Forms Developer와

Oracle9i: Program with PL/SQL I-11

이 단원을 마치면 다음을 수행할 수 있습니다.

Oracle9i: Program with PL/SQL 1-2

e I문과 블록의 데이터를 조작하기 위한 PL/SQL

ra 수행할 작업을 지정합니다.

Oracle9i: Program with PL/SQL 1-3

Oracle9i: Program with PL/SQL 1-4

END; END; END;

Oracle9i: Program with PL/SQL 1-5

응용 프로그램 트 응용 프로그램 이벤트와 연결되어 있으며 자동 실행되는 Oracle Forms Developer 등

변수가 사용되는 작업:

Oracle9i: Program with PL/SQL 1-7

y 선언 부분에서 변수를 선언하고 초기화합니다.

Oracle9i: Program with PL/SQL 1-8

Oracle9i: Program with PL/SQL 1-9

y PL/SQL에는 자체 입력 또는 출력 기능이 없습니다.

y 앰퍼샌드를 접두어로 붙이면 PL/SQL 블록 내에서 치환

y iSQL*Plus 호스트(또는 “바인드”) 변수를 사용하면

Oracle9i: Program with PL/SQL 1-10

속에서 태어난, 그리고 만민이 평등하게

256120.08 새 나라를 건설하였습니다.”

Oracle9i: Program with PL/SQL 1-11

e In 스칼라, 조합, 참조 또는 LOB 데이터 유형이 사용됩니다.

Oracle9i: Program with PL/SQL 1-12

Oracle9i: Program with PL/SQL 1-13

Oracle9i: Program with PL/SQL 1-14

Oracle9i: Program with PL/SQL 1-15

Oracle9i: Program with PL/SQL 1-16

Oracle9i: Program with PL/SQL 1-17

c le 데이터베이스 열에는 모든 LONG 값을 삽입할 수 있습니다. 하지만

Oracle9i: Program with PL/SQL 1-18

PLS_INTEGER -2,147,483,647과 2,147,483,647 사이에 있는 부호 표시 정수의 기본 유

Oracle9i: Program with PL/SQL 1-19

Oracle9i: Program with PL/SQL 1-20

Oracle9i: Program with PL/SQL 1-21

Oracle9i: Program with PL/SQL 1-22

y 다음에 따라 변수를 선언합니다.

Oracle9i: Program with PL/SQL 1-23

Oracle9i: Program with PL/SQL 1-24

y 부울 변수에는 TRUE, FALSE 및 NULL 값만 할당할 수