Académique Documents
Professionnel Documents
Culture Documents
SQL is a declarative language that allows database programmers to write a SQL declaration and hand it to the
database for execution. As such, SQL cannot be used to execute procedural code with conditional, iterative
and sequential statements. To overcome this limitation, PL/SQL was created.
PL/SQL is Oracle's Procedural Language extension to SQL. PL/SQL's language syntax, structure and data
types are similar to that of Ada. Some of the statements provided by PL/SQL:
Conditional Control Statements:
IF ... THEN ... ELSIF ... THEN ... ELSE ... END IF;
CASE ... WHEN ... THEN ... ELSE ... END CASE;
Iterative Statements:
GOTO ...;
NULL;
The PL/SQL language includes object oriented programming techniques such as encapsulation, function
overloading, information hiding (all but inheritance).
PL/SQL is commonly used to write data-centric programs to manipulate data in an Oracle database.
Example PL/SQL blocks:
/* Remember to SET SERVEROUTPUT ON to see the output */
BEGIN
DBMS_OUTPUT.PUT_LINE('Hello World');
END;
/
BEGIN
-- A PL/SQL cursor
FOR cursor1 IN (SELECT * FROM table1) -- This is an embedded SQL statement
LOOP
DBMS_OUTPUT.PUT_LINE('Column 1 = ' || cursor1.column1 ||
', Column 2 = ' || cursor1.column2);
END LOOP;
END;
SQL tells the database what to do (declarative), not how to do it. In contrast, PL/SQL tell the database
how to do things (procedural).
SQL is used to code queries, DML and DDL statements. PL/SQL is used to code program blocks,
triggers, functions, procedures and packages.
You can embed SQL in a PL/SQL program, but you cannot embed PL/SQL within a SQL statement.
Java:
Incurs some data conversion overhead between the Database and Java type
Java is an Object Orientated language, and modules are structured into classes
PS: Starting with Oracle 10g, .NET procedures can also be stored within the database (Windows
only). Nevertheless, unlike PL/SQL and JAVA, .NET code is not usable on non-Windows systems.
PS: In earlier releases of Oracle it was better to put as much code as possible in procedures rather than
triggers. At that stage procedures executed faster than triggers as triggers had to be re-compiled every time
before executed (unless cached). In more recent releases both triggers and procedures are compiled when
created (stored p-code) and one can add as much code as one likes in either procedures or triggers. However,
it is still considered a best practice to put as much of your program logic as possible into packages, rather than
triggers.
How can one search PL/SQL code for a string/ key value?
The following query is handy if you want to know where certain tables, columns and expressions are
referenced in your PL/SQL source code.
SELECT type, name, line
FROM
user_source
WHERE
If you run the above query from SQL*Plus, enter the string you are searching for when prompted for
KEYWORD. If not, replace &KEYWORD with the string you are searching for.
proprietary algorithms and methods. Oracle will still understand and know how to execute the code. Just be
careful, there is no "decode" command available. So, don't lose your source!
The syntax is:
wrap iname=myscript.pls oname=xxxx.plb
Please note: there is no legal way to unwrap a *.plb binary file. You are supposed to backup and keep your
*.pls source files after wrapping them. However it is possible for skilled hackers to unwrap your wrapped
Oracle PL/SQL code.
CONNECT / AS SYSDBA
CREATE OR REPLACE DIRECTORY mydir AS '/tmp';
GRANT read, write ON DIRECTORY mydir TO scott;
Provide user access to the UTL_FILE package (created by catproc.sql):
GRANT EXECUTE ON UTL_FILE TO scott;
Copy and paste these examples to get you started:
Write File
DECLARE
fHandler UTL_FILE.FILE_TYPE;
BEGIN
fHandler := UTL_FILE.FOPEN('MYDIR', 'myfile', 'w');
UTL_FILE.PUTF(fHandler, 'Look ma, Im writing to a file!!!\n');
UTL_FILE.FCLOSE(fHandler);
EXCEPTION
WHEN utl_file.invalid_path THEN
raise_application_error(-20000, 'Invalid path. Create directory or set
UTL_FILE_DIR.');
END;
/
Read File
DECLARE
fHandler UTL_FILE.FILE_TYPE;
buf
varchar2(4000);
BEGIN
fHandler := UTL_FILE.FOPEN('MYDIR', 'myfile', 'r');
UTL_FILE.GET_LINE(fHandler, buf);
dbms_output.put_line('DATA FROM FILE: '||buf);
UTL_FILE.FCLOSE(fHandler);
EXCEPTION
WHEN utl_file.invalid_path THEN
raise_application_error(-20000, 'Invalid path. Create directory or set
UTL_FILE_DIR.');
END;
/
NOTE: UTL_FILE was introduced with Oracle 7.3. Before Oracle 7.3 the only means of writing a file was to use
DBMS_OUTPUT with the SQL*Plus SPOOL command.
rc := DBMS_SQL.EXECUTE(cur);
DBMS_SQL.CLOSE_CURSOR(cur);
END;
/
More complex DBMS_SQL example using bind variables:
CREATE OR REPLACE PROCEDURE DEPARTMENTS(NO IN DEPT.DEPTNO%TYPE) AS
v_cursor integer;
v_dname char(20);
v_rows
integer;
BEGIN
v_cursor := DBMS_SQL.OPEN_CURSOR;
DBMS_SQL.PARSE(v_cursor, 'select dname from dept where deptno > :x',
DBMS_SQL.V7);
DBMS_SQL.BIND_VARIABLE(v_cursor, ':x', no);
DBMS_SQL.DEFINE_COLUMN_CHAR(v_cursor, 1, v_dname, 20);
v_rows := DBMS_SQL.EXECUTE(v_cursor);
loop
if DBMS_SQL.FETCH_ROWS(v_cursor) = 0 then
exit;
end if;
DBMS_SQL.COLUMN_VALUE_CHAR(v_cursor, 1, v_dname);
DBMS_OUTPUT.PUT_LINE('Deptartment name: '||v_dname);
end loop;
DBMS_SQL.CLOSE_CURSOR(v_cursor);
EXCEPTION
when others then
DBMS_SQL.CLOSE_CURSOR(v_cursor);
raise_application_error(-20000, 'Unknown Exception Raised: '||sqlcode||'
'||sqlerrm);
END;
/
DECLARE
v_EmpName emp.ename%TYPE;
BEGIN
SELECT ename INTO v_EmpName FROM emp WHERE ROWNUM = 1;
DBMS_OUTPUT.PUT_LINE('Name = ' || v_EmpName);
END;
/
%ROWTYPE
%ROWTYPE is used to declare a record with the same types as found in the specified database table, view or
cursor. Examples:
DECLARE
v_emp emp%ROWTYPE;
BEGIN
v_emp.empno := 10;
v_emp.ename := 'XXXXXXX';
END;
/
How does one get the value of a sequence into a PL/SQL variable?
Starting with 11g you can directly do the following:
i := sq_sequence.NEXTVAL;
On the previous versions you have to use embedded SQL statements to obtain sequence values:
select sq_sequence.NEXTVAL into :i from dual;
RETURN INTEGER IS
status
NUMBER;
errormsg VARCHAR2(80);
pipe_name VARCHAR2(30);
BEGIN
pipe_name := 'HOST_PIPE';
dbms_pipe.pack_message( cmd );
status := dbms_pipe.send_message(pipe_name);
RETURN status;
END;
/
External Procedure Listeners:
From Oracle 8 one can call external 3GL code in a dynamically linked library (DLL or shared object). One can
write a library in C/ C++ to do whatever is required. Defining this C/C++ function to PL/SQL makes it
executable. Look at this External Procedure example.
Using Java
See example at http://www.orafaq.com/scripts/plsql/oscmd.txt
DBMS_SCHEDULER
In Oracle 10g and above, one can execute OS commands via the DBMS_SCHEDULER package. Look at this
example:
BEGIN
dbms_scheduler.create_job(job_name
job_type
job_action
enabled
auto_drop
END;
/
=>
=>
=>
=>
=>
'myjob',
'executable',
'/app/oracle/x.sh',
TRUE,
TRUE);
exec dbms_scheduler.run_job('myjob');
ORDER BY deptno;
-- Employee cursor all employees for a dept number
CURSOR emp_cur (v_dept_no DEPT.DEPTNO%TYPE) IS
SELECT ename
FROM emp
WHERE deptno = v_dept_no;
BEGIN
FOR dept_rec IN dept_cur LOOP
dbms_output.put_line('Employees in Department '||TO_CHAR(dept_rec.deptno));
FOR emp_rec in emp_cur(dept_rec.deptno) LOOP
dbms_output.put_line('...Employee is '||emp_rec.ename);
END LOOP;
END LOOP;
END;
/
How often should one COMMIT in a PL/SQL loop? / What is the best
commit strategy?
Contrary to popular belief, one should COMMIT less frequently within a PL/SQL loop to prevent ORA-1555
(Snapshot too old) errors. The higher the frequency of commit, the sooner the extents in the undo/ rollback
segments will be cleared for new transactions, causing ORA-1555 errors.
To fix this problem one can easily rewrite code like this:
FOR records IN my_cursor LOOP
...do some stuff...
COMMIT;
END LOOP;
COMMIT;
... to ...
FOR records IN my_cursor LOOP
...do some stuff...
i := i+1;
IF mod(i, 10000) = 0 THEN
COMMIT;
END IF;
END LOOP;
COMMIT;
If you still get ORA-1555 errors, contact your DBA to increase the undo/ rollback segments.
NOTE: Although fetching across COMMITs work with Oracle, is not supported by the ANSI standard.
Issuing frequent commits is bad, bad, BAD! Its the WORST thing you can do just dont do it! In the following
example I will create around 7 million rows and then attempt to update a portion of them serially. In addition, I
will issue a commit every thousandth row.
Example 1.1: Creating a somewhat large table
SQL> create table big_employee_table
2
as
3
select rownum as eid
4
, e.*
5
from hr.employees e
6
, dba_objects do;
Table created.
Elapsed: 00:00:12.23
SQL>
select count(*)
2
from big_employee_table;
COUNT(*)
---------7838713
Elapsed: 00:00:08.11
Before I go on, notice that Oracles Create Table As (CTAS) method blazed thru table creation. Thats 7.84
Million rows in 12.23 seconds. Sometimes, this is the very best method of updating large data sets. The
following block updates 100,000 rows, serially, committing every 1000 rows:
Example 1.2: Updating serially
SQL> declare
2
cursor c is
3
select *
4
from big_employee_table
5
where rownum <= 100000;
6 begin
7
for r in c loop
8
update big_employee_table
9
set salary = salary * 1.03
10
where eid = r.eid;
11
12
if mod ( r.eid, 1000 ) = 0 then
13
commit;
14
end if;
15
end loop;
16 end;
17
Observe that the update took more time than I have patience for ;). At 20 minutes I killed the session. It is
painfully slow and should never be done. Moreover, it chewed up an entire CPU core for the duration. If youre
only updating a few rows, why do it in PL/SQL at all? I like Tom Kytes approach (paraphrasing):
1.
2.
3.
4.
Do
If
If
If
it in SQL.
SQL cant do it, do it in PL/SQL.
PL/SQL cant do it, do it in Java.
Java cant do it ask yourself if it needs to be done.
30
31
32
33
34
35
36
37
38
39
I can SELECT from SQL*Plus but not from PL/SQL. What is wrong?
PL/SQL respect object privileges given directly to the user, but does not observe privileges given through roles.
The consequence is that a SQL statement can work in SQL*Plus, but will give an error in PL/SQL. Choose one
of the following solutions:
Grant direct access on the tables to your user. Do not use roles!
A row-level trigger cannot query or modify a mutating table. (Of course, NEW and OLD still can be
accessed by the trigger).
A statement-level trigger cannot query or modify a mutating table if the trigger is fired as the result of a
CASCADE delete.
Etc.
BEGIN
pcalled@DBLINK2(TabX);
END;
/
You can have DML (insert,update, delete) statements in a function. But, you cannot call such a
function in a SQL query. (However an autonomous transaction function can.)
What are the PL/SQL compiler limits for block, record, subquery and
label nesting?
The following limits apply:
Level of Block Nesting: 255
Level of Record Nesting: 32
Level of Subquery Nesting: 254
Level of Label Nesting: 98
Table created.
SQL> CREATE TABLE log (timestamp DATE, operation VARCHAR2(2000));
Table created.
SQL> CREATE TRIGGER tab1_trig
2
AFTER insert ON tab1
3 BEGIN
4
INSERT INTO log VALUES (SYSDATE, 'Insert on TAB1');
5
COMMIT;
6 END;
7 /
Trigger created.
SQL> INSERT INTO tab1 VALUES (1);
INSERT INTO tab1 VALUES (1)
*
ERROR at line 1:
ORA-04092: cannot COMMIT in a trigger
ORA-06512: at "SCOTT.TAB1_TRIG", line 3
ORA-04088: error during execution of trigger 'SCOTT.TAB1_TRIG'
Autonomous transactions:
As workaround, one can use autonomous transactions. Autonomous transactions execute separate from the
current transaction.
Unlike regular triggers, autonomous triggers can contain COMMIT and ROLLBACK statements. Example:
SQL> CREATE OR REPLACE TRIGGER tab1_trig
2
AFTER insert ON tab1
3 DECLARE
4
PRAGMA AUTONOMOUS_TRANSACTION;
5 BEGIN
6
INSERT INTO log VALUES (SYSDATE, 'Insert on TAB1');
7
COMMIT; -- only allowed in autonomous triggers
8 END;
9 /
Trigger created.
SQL> INSERT INTO tab1 VALUES (1);
1 row created.
Note that with the above example will insert and commit log entries - even if the main transaction is rolled-back!
Remember that an "autonomous_transaction" procedure/function/trigger is a whole transaction in itself and so it
must end with a commit or a rollback statement.