Creating Schema

Creating Schema
rem $Header: exampbld.sql,v 1.1 1992/12/02 16:27:31 GCLOSSMA Exp $

rem
Rem Copyright (c) 1991, 1997, 1998 by Oracle Corporation
Rem
NAME
Rem
exampbld.sql Rem
DESCRIPTION
Rem
Rem
RETURNS
Rem
Rem
NOTES
Rem
Rem
MODIFIED
(MM/DD/YY)
Rem
nle
10/22/98 - fix merging problem
Rem
nmantrav
08/10/98 - dropping tables before types.
Rem
sabburi
06/15/98 - create types for objects demo
Rem
sabburi
07/09/97 - Updating compatibility flag.
Rem
gclossma
12/02/92 - Creation
SPOOL exampbld.dbg
SET COMPATIBILITY V7 ;
DROP TABLE accounts ;

CREATE TABLE accounts
(
account_id number(4) not null,
bal
number(11,2) ) ;
CREATE UNIQUE INDEX accounts_index
ON accounts (account_id) ;
DROP TABLE action ;

CREATE TABLE action
( account_id number(4) not null,
oper_type
char(1) not null,
new_value
number(11,2),
status
char(45),
time_tag
date not null ) ;
DROP TABLE bins ;

CREATE TABLE bins
( bin_num
number(2) not null,
part_num
number(4),
amt_in_bin number(4)) ;
DROP TABLE data_table ;

CREATE TABLE data_table
( exper_num number(2),
n1
number(5),
n2
number(5),
n3
number(5)) ;
DROP TABLE emp ;

CREATE TABLE emp
( empno
number(4) not null,
ename
varchar2(10),
job
varchar2(9),
mgr
number(4),
hiredate
date,
sal
number(7,2),
comm
number(7,2),
deptno
number(2)) ;
DROP TABLE inventory ;

CREATE TABLE inventory
( prod_id
number(5) not null,
product
char(15),
quantity
number(5)) ;
DROP TABLE journal ;

CREATE TABLE journal
( account_id
number(4) not null,
action
char(45) not null,
amount
number(11,2),
date_tag
date not null ) ;
DROP TABLE num1_tab ;

CREATE TABLE num1_tab(
sequence
number(3) not null,
num
number(4)) ;
DROP TABLE num2_tab ;

CREATE TABLE num2_tab
( sequence
number(3) not null,
num
number(4)) ;
DROP TABLE purchase_record ;

CREATE TABLE purchase_record
( mesg
char(45),
purch_date date) ;
DROP TABLE ratio ;

CREATE TABLE ratio
( sample_id number(3) not null,
ratio
number) ;
DROP TABLE result_table ;

CREATE TABLE result_table
( sample_id number(3) not null,
x
number,
y
number) ;
DROP TABLE sum_tab ;

CREATE TABLE sum_tab
( sequence
number(3) not null,
sum
number(5)) ;
DROP TABLE temp ;

CREATE TABLE temp
( num_col1
number(9,4),
num_col2
number(9,4),
char_col
char(55)) ;
CREATE OR REPLACE PACKAGE personnel

IS
TYPE charArrayTyp IS TABLE OF VARCHAR2(10)
INDEX BY BINARY_INTEGER ;
TYPE numArrayTyp IS TABLE OF FLOAT
INDEX BY BINARY_INTEGER ;
PROCEDURE get_employees
( dept_number in
integer,
batch_size in
integer,
found
in out integer,
done_fetch out
integer,
emp_name
out
charArrayTyp,
job_title
out
charArrayTyp,
salary
out
numArrayTyp ) ;
END personnel;
/
CREATE OR REPLACE PACKAGE BODY personnel
IS
CURSOR get_emp ( dept_number INTEGER ) IS
SELECT ename, job, sal
FROM
emp
WHERE deptno = dept_number ;
PROCEDURE get_employees
( dept_number in
integer,
batch_size in
integer,
found
in out integer,
done_fetch out
integer,
emp_name
out
charArrayTyp,
job_title
out
charArrayTyp,
salary
out
numArrayTyp )
IS
BEGIN
IF NOT get_emp%ISOPEN THEN
OPEN get_emp(dept_number);
END IF;
done_fetch := 0;
found := 0;
FOR i IN 1..batch_size
LOOP
FETCH get_emp
INTO emp_name(i) , job_title(i) , salary(i);
if get_emp%notfound then
close get_emp;
done_fetch := 1;
exit;
else
found := found + 1;
end if;
end loop;
end get_employees;
end personnel;
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
TABLE ot_customer
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
DROP
/
TYPE o_customer
TABLE ot_account
TABLE ot_account_type_1
TABLE ot_person
TABLE transaction_tab
SEQUENCE acct_sequence
TYPE o_account
TYPE v_account_type
TYPE o_account_type_1
TYPE o_person
TYPE o_address
/*
** ##############################################################
**
**
CREATION OF OBJECT TYPES and TABLES
**
** ##############################################################
*/
/* Sequence is created to get unique account numbers for the
different account types.
*/
CREATE SEQUENCE acct_sequence START WITH 123456 INCREMENT BY 1
/
/* A function to return blank spaces */
/* This is used in the generation of statement */
CREATE OR REPLACE FUNCTION sp(n IN INTEGER) RETURN VARCHAR2
AS
num INTEGER;
space VARCHAR2(80);
BEGIN
space := '';
FOR num IN 1..n

LOOP
space := space||' ';
END LOOP;
RETURN space;
END;
/
show errors
/*
Transaction table
----------------Table for maintaining the transactions.
*/
CREATE TABLE transaction_tab

(
account_num INTEGER,
transaction_date DATE,
transaction_amount NUMBER,
balance NUMBER,
transaction_type CHAR
)
/
/*
Address type
-----------This type is for storing the address of the customers
*/
CREATE OR REPLACE TYPE o_address AS OBJECT
(
housenum VARCHAR2(10),
street
VARCHAR2(15),
city
VARCHAR2(20),
country VARCHAR2(20),
zipcode VARCHAR2(10)
)
/
/*
Person type:
----------This type is for storing the person information.
*/
CREATE OR REPLACE TYPE o_person AS OBJECT
(
ssn
VARCHAR2(15),
name
VARCHAR2(50),
birthdate DATE,
gender
CHAR,
address
o_address
)
/
/* --------- Creating PERSON TABLE(ot_person) of o_person type -------- */

CREATE TABLE ot_person OF o_person
/
/*
Account_type_1
-------------This type has the information if the customer opens a account_type_1.
*/
CREATE or REPLACE TYPE o_account_type_1 AS OBJECT
(
accountnum INTEGER,
balance
NUMBER,
MEMBER FUNCTION open_account(SELF IN OUT o_account_type_1, amount IN NUMBER)
RETURN o_account_type_1
)
/
/*
---------- Create object table for account_type_1 --------- */
CREATE TABLE ot_account_type_1 OF o_account_type_1

/
CREATE or REPLACE TYPE BODY o_account_type_1 as
MEMBER FUNCTION open_account(SELF IN OUT o_account_type_1,amount IN NUMBER)
RETURN o_account_type_1 AS
-- open account with initial deposit in account_type_1
BEGIN
IF NOT amount > 0 THEN
DBMS_OUTPUT.PUT_LINE('Bad amount entered');
RETURN o_account_type_1(0,0);
END IF;
account
IF amount < 250 THEN

DBMS_OUTPUT.PUT_LINE('The minimum amount for accounttype1 should be 250');
RETURN o_account_type_1(0,0);
ELSE
-- Generate account number
SELECT acct_sequence.NEXTVAL INTO accountnum FROM DUAL;
-- Insert customer details into account_type_1 table
INSERT INTO ot_account_type_1 VALUES(accountnum,amount);
return o_account_type_1(accountnum,amount);
END IF;
END open_account;
END;
/
show errors
/*
Account_type_2 type:
--------------------This type has the information if the customer has a account_type_2.
*/
(
accountnum INTEGER,
balance
NUMBER,
RETURN INTEGER
)
/
/*

/
CREATE or REPLACE TYPE BODY o_account_type_2 AS
RETURN INTEGER AS
-- open account with initial deposit in account_type_2
BEGIN
IF amount <= 0 THEN
RETURN 0;
END IF;
-- Generate account number
-- Inserts customer details.
RETURN accountnum;
END open_account;
END;
/
show errors
/*
Account_type_3 type:
-------------------This type has the information if the customer has a account_type_3.
*/
(
accountnum INTEGER,
balance NUMBER,
RETURN INTEGER
)
/
/*

/
CREATE or REPLACE TYPE BODY o_account_type_3 AS
RETURN INTEGER AS
BEGIN
IF NOT amount > 0 THEN
RETURN 0;
END IF;
IF (amount > 25000) THEN
DBMS_OUTPUT.PUT_LINE('Amount greater the specified cannot be withdrawn');
RETURN 0;
ELSE
RETURN accountnum;
END IF;
END open_account;
END;
/
show errors
/*
Accounts type:
------------This has the information about the types of accounts a customer has
in the bank.
Attributes:
SSN is the ssn of the customer.
(A customer can have multiple accounts but ssn remains the same)
ACCOUNT_TYPE Stores the name of the account types as the elements of
varray.
ACCOUNTTYPE1 points to an object of type Account_type_1.
Methods:
Open_account()
Verify_account()
Deposit_amount()
withdraw_amount()
Close_account()
Current_balance()
- Opens new accounts for the customers.

- Verifies if the account number exists
for any transaction to be done.
- Deposit amount to the corresponding account.
- Withdraws amount from the corresponding account.
- Closes account .
- Returns the current balance for the given account no.
*/
-- Store the account types as elements of VARRAY
CREATE or REPLACE TYPE v_account_type AS VARRAY(5) OF VARCHAR2(5)
/
CREATE or REPLACE TYPE o_account AS OBJECT
(
ssn
varchar2(15),
account_type
v_account_type,
accounttype1 REF
o_account_type_1,
accounttype2 REF
o_account_type_2,
accounttype3 REF
o_account_type_3,
MEMBER FUNCTION open_account(SELF IN OUT o_account, ssn_num IN VARCHAR2,
accounttype IN VARCHAR2, amount IN NUMBER,
name IN VARCHAR2, bday IN DATE,
gender IN CHAR, addr o_address)
RETURN INTEGER,
MEMBER PROCEDURE insert_person(p_ssn IN VARCHAR2,p_name IN VARCHAR2,
p_bday IN DATE,p_gender IN CHAR,
p_addr o_address),
MEMBER FUNCTION verify_account(SELF IN OUT o_account, acctnum IN INTEGER)
RETURN INTEGER,
MEMBER PROCEDURE deposit_amount(acctnum IN INTEGER,amount IN NUMBER),
MEMBER PROCEDURE withdraw_amount(acctnum IN INTEGER,amount IN NUMBER),
MEMBER PROCEDURE current_balance(acctnum IN INTEGER),
MEMBER PROCEDURE person_details(ssn_num IN VARCHAR2),
MEMBER PROCEDURE report_form(actnum IN INTEGER),
MEMBER PROCEDURE trans_details(ssn_num IN VARCHAR2),
MEMBER PROCEDURE close_account(acctnum IN INTEGER)
)
/
/* ---------------- Create object table of o_account type ----------------- */
CREATE TABLE ot_account of o_account
/
/*
Private customer type:
---------------------
*/
Information about the private customers. It stores the information of

another person if a customer has a joint account.
CREATE or REPLACE TYPE o_customer AS OBJECT

(
owner REF o_person,
ref_o_account REF o_account
)
/
/* ---------- Create object table for Customer Type --------- */
CREATE TABLE ot_customer OF o_customer
/
CREATE or REPLACE TYPE BODY o_account AS
MEMBER PROCEDURE insert_person(p_ssn IN VARCHAR2,p_name IN VARCHAR2,
p_bday IN DATE,p_gender IN CHAR,
p_addr o_address) AS
BEGIN
INSERT INTO ot_person VALUES(p_ssn,p_name,p_bday,p_gender,
o_address(p_addr.housenum,p_addr.street,
p_addr.city,p_addr.country,
p_addr.zipcode));
END insert_person;
/*------------------------------------------------------------------------- */
/* For new customers(who do not have an account in the bank)
1) insert customer details into PERSON table
2) create a new account
For existing customers who want to open another
account(different account type),
1) Create a new account
To create a new account following operations are done
1. Call open_account method in the corresponding account type.
2. Make an entry of the account type in the ACCOUNT_TYPE varray
3. Update the corresponding REF to point to the corresponding
account type object
For e.g to open an ACCOUNT_TYPE1 account,
1. Call open_account in accounttype1
2. Extend VARRAY(v_account_type) and initialise the new element to AT1
3. Point the REF in ot_account object table to accounttype1 object
*/
MEMBER FUNCTION open_account(SELF IN OUT o_account,ssn_num IN VARCHAR2,

accounttype IN VARCHAR2,
amount IN NUMBER, name IN VARCHAR2,
bday IN DATE,gender IN CHAR,
addr o_address)
RETURN INTEGER AS
/*
*/
l_accounttype1,2,3 need to be defined before the corresponding

OPEN_ACCOUNT method can be called
l_accounttype1 o_account_type_1 := o_account_type_1(null,null);

l_amount NUMBER;
account_type_exists EXCEPTION;
no_account_type_exists EXCEPTION;
l_accountnum INTEGER;
l_count INTEGER;
l_account_type v_account_type := v_account_type(NULL);
l_stat INTEGER := 0;
n INTEGER;
first_time VARCHAR2(6) := 'TRUE';
ref_to_at1 REF o_account_type_1;
BEGIN
-- Check if the person has an account by checking if the ssn exists in
-- the ot_account table.
-- If the select returns an exception "NO_DATA_FOUND" the person does
-- not have an account. Create a new account.
-- If the select returns does not raise NO_DATA_FOUND exception then
-- the existence of the account of the accounttype passed is checked.
-- If the person has an account of the given accounttype then it raises
-- an exception account_type_exists.
-- If the person has an account in the bank but not of the given type then
-- an exception no_account_type_exists is raised.
SELECT account_type,accounttype1,accounttype2,accounttype3 INTO
l_account_type,ref_to_at1,ref_to_at2,ref_to_at3 FROM ot_account
WHERE ssn=ssn_num;
-- loop through all the elements in the VARRAY to check if the
-- accounttype exists.
first_time := 'FALSE';
FOR n IN 1..l_account_type.COUNT
LOOP
-- Check if the user has an account of the accounttype passed.
IF (l_account_type(n) = accounttype) THEN
RAISE account_type_exists;
ELSE
RAISE no_account_type_exists;
END IF;
END LOOP;
EXCEPTION
WHEN NO_DATA_FOUND OR no_account_type_exists THEN
IF (accounttype = 'AT1') THEN
-- Create a new account of the type accounttype
l_accounttype1 := l_accounttype1.open_account(amount);
l_accountnum := l_accounttype1.accountnum;
IF (l_accountnum != 0) THEN
SELECT REF(at1) INTO ref_to_at1 FROM ot_account_type_1 at1
WHERE at1.accountnum = l_accountnum;
END IF;
ELSIF (accounttype = 'AT2') THEN
l_accountnum := l_accounttype2.open_account(amount);
END IF;
ELSIF (accounttype = 'AT3') THEN
l_accountnum := l_accounttype3.open_account(amount);
END IF;
END IF;
IF(l_accountnum != 0) THEN
-- Valid account details , next check new or old customer.
-- If new customer insert details to the person table and account table.
INSERT INTO transaction_tab VALUES(l_accountnum,to_date('01-JAN98'),amount,
amount,'O');
IF (first_time = 'TRUE') THEN
-- The personal details of the customer is entered for a new customer.
l_account_type(1) := accounttype;
INSERT INTO ot_account VALUES(ssn_num,l_account_type, NULL,NULL,NULL);
INSERT INTO ot_customer VALUES(NULL,NULL);
insert_person(ssn_num,name,bday,gender,addr);
UPDATE ot_customer t SET t.owner=(SELECT REF(x) FROM ot_person x
WHERE x.ssn=ssn_num);
ELSE
-- Entry for a old customer but opening an account of a different type.
n := l_account_type.COUNT;
l_account_type.EXTEND(1);
l_account_type(n+1) := accounttype;
END IF;
-- Update the attributes in ot_account table to point to the
-- corresponding account types.
UPDATE ot_account t SET t.account_type = l_account_type,
t.accounttype1=ref_to_at1,t.accounttype2=ref_to_at2,
t.accounttype3=ref_to_at3 WHERE t.ssn=ssn_num;
UPDATE ot_customer t SET t.ref_o_account=(SELECT REF(x) FROM ot_account
x WHERE x.ssn = ssn_num);
DBMS_OUTPUT.PUT_LINE('Accountnumber assigned is '|| l_accountnum);
END IF;
RETURN l_accountnum;
WHEN account_type_exists THEN
DBMS_OUTPUT.PUT_LINE('Account already exists, so cannot open');
END open_account;
/*-------------------------------------------------------------------- */
/*
Verifies if the account number exists and returns 0,1,2,3.

Return Value
What it means
-----------------------------------------------------------0
Account is closed/does not exist
1
Valid account_type_1 Account
2
3
*/
MEMBER FUNCTION verify_account(SELF IN OUT o_account,acctnum IN INTEGER)
RETURN INTEGER IS
l_count1 INTEGER;
l_count2 INTEGER;
l_count3 INTEGER;
l_closecount INTEGER;
BEGIN
-- Check if the account is closed
SELECT COUNT(*) INTO l_closecount FROM transaction_tab WHERE
account_num=acctnum AND transaction_type='C';
IF (l_closecount = 1) THEN
DBMS_OUTPUT.PUT_LINE('Account is already closed. Cannot do any' ||
'transaction');
RETURN 0;
END IF;
-- Valid account - check if it is of account_type_1
SELECT COUNT(*) INTO l_count1 FROM ot_account_type_1 WHERE
accountnum = acctnum;
IF (l_count1=1 AND l_closecount = 0) THEN
RETURN 1;
END IF;
RETURN 2;
END IF;
RETURN 3;
END IF;
-- Seems like Account No. does not exist
IF(l_count1 = 0 OR l_count2 = 0 OR l_count3 = 0) THEN
DBMS_OUTPUT.PUT_LINE('Account number does not exist');
RETURN 0;
END IF;
END verify_account;
/*----------------------------------------------------------------------- */
/*
Deposit amount after checking if the account exists. Update
the transaction table accordingly.
To verify if the account exists call the method, verify_account
If the return value is,
1 - Update the balance in account_type_1 table
*/
MEMBER PROCEDURE deposit_amount(acctnum IN INTEGER,amount IN NUMBER) AS
l_exists INTEGER;
l_balance NUMBER;
BEGIN
l_exists := self.verify_account(acctnum);
IF (l_exists = 1) THEN
UPDATE ot_account_type_1 SET balance=balance+amount WHERE
SELECT balance INTO l_balance FROM ot_account_type_1 WHERE
ELSIF (l_exists = 2) THEN
UPDATE ot_account_type_2 SET balance=balance+amount WHERE
ELSIF (l_exists = 3 ) THEN
UPDATE ot_account_type_3 SET balance = balance - amount WHERE
accountnum=acctnum;
END IF;
DBMS_OUTPUT.PUT_LINE('Balance in the account is ' || l_balance);
INSERT INTO transaction_tab VALUES(acctnum, to_date('01-MAR98'),amount,l_balance, 'D');
DBMS_OUTPUT.PUT_LINE('Deposited the amount for the given person');
END deposit_amount;
/* ---------------------------------------------------------------------- */
/*
Withdraw amount after checking if the account exists. Update

1 - If the balance > 250,update the balance in account_type_1 table
2 - If the balance > 0, update the balance in account_type_2 table
3 - If the balance > 25000, update the balance in account_type_3 table
*/
MEMBER PROCEDURE withdraw_amount(acctnum IN INTEGER,amount IN NUMBER) AS
l_exists INTEGER;
l_balance NUMBER;
BEGIN
l_exists := verify_account(acctnum);
l_balance := l_balance - amount;
IF (l_balance < 250) THEN
DBMS_OUTPUT.PUT_LINE('The minimum limit in the account should be 250');
ELSE
UPDATE ot_account_type_1 SET balance=l_balance WHERE
accountnum=acctnum;
END IF;
l_balance := l_balance - amount;
IF (l_balance < 0) THEN
DBMS_OUTPUT.PUT_LINE('The minimum limit in the account should not be'||
' negative');
ELSE
accountnum=acctnum;
END IF;
l_balance := l_balance + amount;
IF (l_balance > 25000) THEN
DBMS_OUTPUT.PUT_LINE('The amount cannot be withdrawn beyond 25000');
ELSE
accountnum=acctnum;
END IF;
END IF;
INSERT INTO transaction_tab VALUES(acctnum, to_date('01-APR98'),amount,l_balance, 'W');

DBMS_OUTPUT.PUT_LINE('Balance in the account is ' || l_balance);
END withdraw_amount;
/* ----------------------------------------------------------------------- */
/*
Display the current balance after verifying for the existence of the
account
*/
MEMBER PROCEDURE current_balance(acctnum IN INTEGER) AS
l_exists INTEGER;
l_balance NUMBER;
BEGIN
ELSIF ( l_exists = 2) THEN
END IF;
DBMS_OUTPUT.PUT_LINE('Current balance for the given account number ' ||
l_balance);
END;
/* ------------------------------------------------------------------------ */
MEMBER PROCEDURE person_details(ssn_num IN VARCHAR2) AS
l_o_address o_address;
l_name VARCHAR2(50);
l_bdate DATE;
BEGIN
SELECT NAME,BIRTHDATE,ADDRESS INTO l_name,l_bdate,l_o_address FROM
ot_person WHERE ssn=ssn_num;
DBMS_OUTPUT.PUT_LINE('SSN
: '||
DBMS_OUTPUT.PUT_LINE('Name
: '||
DBMS_OUTPUT.PUT_LINE('Birthdate: '||
DBMS_OUTPUT.PUT_LINE('');
DBMS_OUTPUT.PUT_LINE('Address ');
DBMS_OUTPUT.PUT_LINE('------- ');
DBMS_OUTPUT.PUT_LINE('Housenum : '||
DBMS_OUTPUT.PUT_LINE('Street
: '||
ssn_num);
l_name);
l_bdate);
l_o_address.housenum);
l_o_address.street);
DBMS_OUTPUT.PUT_LINE('City
DBMS_OUTPUT.PUT_LINE('Country
DBMS_OUTPUT.PUT_LINE('Zipcode
: '|| l_o_address.city);
: '|| l_o_address.country);
: '|| l_o_address.zipcode);
END;
/* ---------------------------------------------------------------------- */
MEMBER PROCEDURE report_form(actnum IN INTEGER) AS
var1 VARCHAR2(2000);
head VARCHAR2(200);
BEGIN
DBMS_OUTPUT.PUT_LINE('---------------------------------------------------'||
'-------------------------');
head := '|
Date
| Opening amt. |Amt Deposited |Amt withdrawn |'
||'
Balance |';
DBMS_OUTPUT.PUT_LINE(head);
'-------------------------');
FOR c1 IN(SELECT transaction_date,transaction_amount,balance,
transaction_type FROM transaction_tab WHERE account_num=actnum)
LOOP
var1 := '|' || sp(2) || c1.transaction_date ||sp(2) || '|';
IF (c1.transaction_type = 'D') THEN
var1 := var1 || sp(14)||'|'||sp(2) ||
to_char(c1.transaction_amount,'99999.99') ||
sp(3) || '|' || sp(15) || '|';
ELSIF (c1.transaction_type = 'W') THEN
var1 := var1 || sp(14) ||'|' || sp(14) ||'|' ||
to_char(c1.transaction_amount,'99999.99') || sp(6) || '|';
ELSIF (c1.transaction_type = 'O') THEN
var1 := var1 || sp(2) || to_char(c1.transaction_amount,'99999.99')||
sp(3)|| '|' || sp(14) ||'|' || sp(15) ||'|';
END IF;
var1 := var1 || sp(3) || to_char(c1.balance,'99999.99') || sp(2) || '|';
DBMS_OUTPUT.PUT_LINE(var1);
END LOOP;
'-------------------------');
END;
/*---------------------------------------------------------------------------*/
MEMBER PROCEDURE trans_details(ssn_num IN VARCHAR2) AS
l_name VARCHAR2(50);
l_account_type v_account_type;
l_ref1 REF o_account_type_1;
l_accounttype1 o_account_type_1;
l_count INTEGER;
n INTEGER;
BEGIN
SELECT COUNT(*) INTO l_count FROM ot_account WHERE ssn=ssn_num;
IF(l_count > 0) THEN
-- Get all details of the customer from the person table and
-- ot_account table.
SELECT t.account_type,t.accounttype1,t.accounttype2,t.accounttype3 INTO
l_account_type,l_ref1,l_ref2,l_ref3 FROM ot_account t
WHERE t.ssn=ssn_num;
DBMS_OUTPUT.PUT_LINE('Details for the customer ');
person_details(ssn_num);
FOR n IN 1..l_account_type.COUNT
LOOP
IF(l_account_type(n) = 'AT1') THEN
-- Get the details for accounttype1.
SELECT DEREF(l_ref1) INTO l_accounttype1 from dual;
DBMS_OUTPUT.PUT_LINE('Transaction details for accountno. '
|| l_accounttype1.accountnum);
DBMS_OUTPUT.PUT_LINE('Accounttype: '|| 'AT1');
report_form(l_accounttype1.accountnum);
ELSIF(l_account_type(n) = 'AT2') THEN
|| l_accounttype2.accountnum);
ELSIF(l_account_type(n) = 'AT3') THEN
||l_accounttype3.accountnum );
END IF;
END LOOP;
ELSE
DBMS_OUTPUT.PUT_LINE('The given ssn does not exist');
END IF;
END;
/*---------------------------------------------------------------------------*/
/*
Close account after checking if the account exists. Update


1 - Pay remaining balance in account_type_1 to the customer
2 - Pay remaining balance in account_type_2 to the customer
3 - Account will be closed after the customer pays the amount due
*/
MEMBER PROCEDURE close_account(acctnum IN INTEGER) AS
l_exists INTEGER;
l_balance NUMBER;
BEGIN
IF(l_exists = 1) THEN
DBMS_OUTPUT.PUT_LINE('Closing balance is ' || l_balance);
ELSIF(l_exists = 2) THEN
DBMS_OUTPUT.PUT_LINE('Closing balance is ' || l_balance);
ELSIF(l_exists = 3) THEN
IF ( l_balance > 0) THEN
DBMS_OUTPUT.PUT_LINE('Pending amount to be paid by the customer is'
|| l_balance);
ELSE
DBMS_OUTPUT.PUT_LINE('Account closed');
END IF;
INSERT INTO transaction_tab VALUES(acctnum,to_date('01-MAY-98'),
l_balance,0,'C');
END IF;
END close_account;
END;
/
show errors
SPOOL OFF

Creating Schema

Uploaded by

Document Information

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

Creating Schema

Uploaded by

Copyright:

Available Formats

Creating Schema

rem $Header: exampbld.sql,v 1.1 1992/12/02 16:27:31 GCLOSSMA Exp $

DROP TABLE accounts ;

DROP TABLE action ;

DROP TABLE bins ;

DROP TABLE data_table ;

DROP TABLE emp ;

DROP TABLE inventory ;

DROP TABLE journal ;

DROP TABLE num1_tab ;

DROP TABLE num2_tab ;

DROP TABLE purchase_record ;

DROP TABLE ratio ;

DROP TABLE result_table ;

DROP TABLE sum_tab ;

DROP TABLE temp ;

CREATE OR REPLACE PACKAGE personnel

FOR num IN 1..n

CREATE TABLE transaction_tab

/* --------- Creating PERSON TABLE(ot_person) of o_person type -------- */

---------- Create object table for account_type_1 --------- */

CREATE TABLE ot_account_type_1 OF o_account_type_1

IF amount < 250 THEN

---------- Create object table for account_type_2 --------- */

CREATE TABLE ot_account_type_2 OF o_account_type_2

---------- Create object table for account_type_3 --------- */

CREATE TABLE ot_account_type_3 OF o_account_type_3

- Opens new accounts for the customers.

Information about the private customers. It stores the information of

CREATE or REPLACE TYPE o_customer AS OBJECT

MEMBER FUNCTION open_account(SELF IN OUT o_account,ssn_num IN VARCHAR2,

l_accounttype1,2,3 need to be defined before the corresponding

l_accounttype1 o_account_type_1 := o_account_type_1(null,null);

Verifies if the account number exists and returns 0,1,2,3.

Withdraw amount after checking if the account exists. Update

INSERT INTO transaction_tab VALUES(acctnum, to_date('01-APR98'),amount,l_balance, 'W');

Close account after checking if the account exists. Update

To verify if the account exists call the method, verify_account

You might also like