info@amis.nl
Subject: mail for Alex Nuijten – Response to “Contract-Oriented PL/SQL Coding”

Best regards,
Zlatko Sirotic

Sorry about that, Zlatko, Apperently the formatting is lost when using comments… if you could mail the source to me, I could place it in the body of the post (of course with credits to you)

Regards,
Zlatko Sirotic

Contract is based on routine’s putting up an obligation to caller (to some other routine)
to satisfy conditions of precondition and conditions of invariant, and hers (called routine’s) obligation
to satisfy conditions of postcondition and conditions of invariant.
The object oriented Eiffel programming language was created to implement DBC.

For now, other object-oriented languages don’t support directly the ideas behind DBC.
However, precondition and postcondition are applicable to many programming languages, both object oriented and not OO.
Invariants are applicable only in OOPL.

This is my attempt to use DBC methodology (including invariants) in Oracle PL/SQL

Class interface from Bertrand Meyer’s book “Object oriented software construction”, second edition (OOSC2), page 390-391:

class interface STACK [G]

creation make

feature — Initialization
make (n: INTEGER) is — Alocate stack for a maximum of n elements
require
non_negative_capacity: n >= 0
ensure
capacity_set: capacity = n
end

feature — Access
capacity: INTEGER — Maximum number of stack elements

count: INTEGER — Number of stack elements

item: G is -– Top element
require
not_empty: not empty
end

feature — Status report
empty: BOOLEAN is –- Is stack empty?
ensure
empty_definition: Result = (count = 0)
end

full: BOOLEAN is –- Is stack full?
ensure
full_definition: Result = (count = capacity)
end

feature — Element change
put (x: G) is –- Add x on top
require
not_full: not full
ensure
not_empty: not empty
added_to_top: item = x
one_more_item: count = old count + 1
end

remove is -– Remove top element
require
not_empty: not empty
ensure
not_full: not full
one_fewer: count = old count – 1
end

invariant
count_non_negative: 0 = 1 AND n = 2 AND capacity n THEN
dbc.display_error (‘stack – POST’);
END IF;

check_invariants;
END;

MEMBER FUNCTION item (SELF IN OUT stack) RETURN INTEGER IS
BEGIN
IF dbc.checking_level >= 1 AND empty THEN
dbc.display_error (‘item – PRE’);
END IF;

check_invariants;

RETURN implement(el_count);
END;

MEMBER FUNCTION empty RETURN BOOLEAN IS
BEGIN
IF el_count = 0 THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END;

MEMBER FUNCTION full RETURN BOOLEAN IS
BEGIN
IF el_count = capacity THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END;

MEMBER PROCEDURE put (x INTEGER) IS
BEGIN
IF dbc.checking_level >= 1 AND full THEN
dbc.display_error (‘put – PRE’);
END IF;

check_invariants;

el_count := el_count + 1;
implement(el_count) := x;

— PL/SQL has not Eiffel’s OLD
— one_more_item: count = old count + 1
IF dbc.checking_level >= 2 AND (empty OR item x) THEN
dbc.display_error (‘put – POST’);
END IF;

check_invariants;
END;

MEMBER PROCEDURE remove IS BEGIN
IF dbc.checking_level >= 1 AND empty THEN
dbc.display_error (‘remove – PRE’);
END IF;

check_invariants;

el_count := el_count – 1;

— PL/SQL has not Eiffel’s OLD
— one_fewer: count = old count – 1
IF dbc.checking_level >= 2 AND full THEN
dbc.display_error (‘remove – POST’);
END IF;

check_invariants;
END;

— INVARIANTS

MEMBER FUNCTION count_non_negative RETURN BOOLEAN IS
BEGIN
IF el_count >= 0 THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END;

MEMBER FUNCTION count_bounded RETURN BOOLEAN IS
BEGIN
IF el_count 0)
THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
END;

MEMBER PROCEDURE check_invariants IS
BEGIN
IF dbc.checking_level