One of the most often uses of the pseudo column rownum is to provide sequence numbers to the records in a query. This feature is widely used in reports to represent systematic display of information.

SELECT   ROWNUM, rcta.trx_number, rcta.trx_date
FROM ra_customer_trx_all rcta;

ROWNUM    TRX_NUMBER    TRX_DATE
1    40881-05    12/14/2005
2    38384-05    11/24/2005
3    42740-05    12/28/2005
4    42742-05    12/28/2005
5    08883-07    3/12/2007
…………………………………..
…………………………………..
However, when we order this statement the rownum gets disturbed as shown below:

SELECT   ROWNUM, rcta.trx_number, rcta.trx_date
FROM ra_customer_trx_all rcta
ORDER BY rcta.trx_number;

ROWNUM    TRX_NUMBER    TRX_DATE
6427    00001-09    1/2/2009
10827    00001-09CM    1/6/2009
6361    00002-09    1/2/2009
10828    00002-09CM    1/6/2009
6248    00003-09    1/2/2009
……………………………………
……………………………………

As we can see from above the transaction number did get ordered but the rownum also got the wrong order. To achieve this we have to outer join this table with dual that process forces a implicit order on the rownum as shown below.

SELECT   ROWNUM, rcta.trx_number, rcta.trx_date
FROM ra_customer_trx_all rcta, DUAL d
WHERE rcta.trx_number = d.dummy(+)
ORDER BY rcta.trx_number;

ROWNUM    TRX_NUMBER    TRX_DATE
1    00001-09    1/2/2009
2    00001-09CM    1/6/2009
3    00002-09    1/2/2009
4    00002-09CM    1/6/2009
5    00003-09    1/2/2009
………………………………….
…………………………………

The trick is to do an outer join with the column that you want to order and this process does not disturb the rownum order. In addition to that if the column is of number datatype then one should make sure to use TO_CHAR datatype conversion function

Operations such as upgrades, patches and DDL changes can invalidate schema objects.  For this reason it makes sense to recompile invalid objects in advance of user calls. It also allows you to identify if any changes have broken your code base.

In order to compile a program, you must own that program (in other words, the schema you specify is the owner of the program for which you request compilation) or your schema must have been granted the ALTER ANY PROCEDURE privilege to compile another schema’s programs.

GRANT ALTER ANY PROCEDURE TO name_of_user;

DBMS_DDL.ALTER_COMPILE

CREATE OR REPLACE PROCEDURE recompile_objects
(status_in IN VARCHAR2 := ‘INVALID’,
name_in IN VARCHAR2 := ‘%’,
type_in IN VARCHAR2 := ‘%’,
schema_in IN VARCHAR2 := USER)
IS
v_objtype VARCHAR2(100);

CURSOR obj_cur IS
SELECT owner, object_name, object_type
FROM ALL_OBJECTS
WHERE status LIKE UPPER (status_in)
AND object_name LIKE UPPER (name_in)
AND object_type LIKE UPPER (type_in)
AND owner LIKE UPPER (schema_in)
ORDER BY
DECODE (object_type,
‘PACKAGE’, 1,
‘FUNCTION’, 2,
‘PROCEDURE’, 3,
‘PACKAGE BODY’, 4);
BEGIN
FOR rec IN obj_cur
LOOP
IF rec.object_type = ‘PACKAGE’
THEN
v_objtype := ‘PACKAGE SPECIFICATION’;
ELSE
v_objtype := rec.object_type;
END IF;

DBMS_DDL.ALTER_COMPILE (v_objtype, rec.owner, rec.object_name);

DBMS_OUTPUT.PUT_LINE
(‘Compiled ‘ || v_objtype || ‘ of ‘ ||
rec.owner || ‘.’ || rec.object_name);
END LOOP;
END recompile_objects;
/

The ALTER_COMPILE procedure may raise any of the following exceptions:

ORA-20000

Insufficient privileges or object does not exist. You must either own the specified object or be granted the CREATE ANY PROCEDURE privilege.

ORA-20001

Remote object, cannot compile. You can only recompile objects on the local database instance.

ORA-20002

Bad value for object type. You need to provide one of the values listed in the previous section.

Notice that these exceptions are not defined in the specification of the package. Instead, ALTER_COMPILE simply calls RAISE_APPLICATION_ERROR with one of the above error numbers. These error numbers may therefore conflict with your own -20NNN error number usages. If you embed calls to ALTER_COMPILE inside your application or utility, watch out for the confusion such conflicts can cause.

Custom Script Using EXECUTE IMMEDIATE

CREATE OR REPLACE PROCEDURE recompile_object
AS
CURSOR my_cur
IS
SELECT   *
FROM dba_objects
WHERE status = ‘INVALID’
ORDER BY owner, object_type, object_name;
BEGIN
FOR cur IN my_cur
LOOP
BEGIN
IF cur.object_type = ‘PACKAGE BODY’
THEN
EXECUTE IMMEDIATE    ‘ALTER PACKAGE ‘
|| cur.owner
|| ‘.’
|| cur.object_name
|| ‘ COMPILE BODY’;
ELSE
EXECUTE IMMEDIATE    ‘ALTER ‘
|| cur.object_type
|| ‘ ‘
|| cur.owner
|| ‘.’
|| cur.object_name
|| ‘ COMPILE’;
END IF;
EXCEPTION
WHEN OTHERS
THEN
DBMS_OUTPUT.put_line (SQLERRM);
DBMS_OUTPUT.put_line (   cur.object_type
|| ‘ : ‘
|| cur.owner
|| ‘ : ‘
|| cur.object_name
);
END;
END LOOP;
EXCEPTION
WHEN OTHERS
THEN
DBMS_OUTPUT.put_line (SQLERRM);
END recompile_object;
/

CREATE OR REPLACE PACKAGE spell_number_pkg AS
/*
Spell Number in Indonesia and English
*/
AMOUNT_EXCEEDS_LIMIT EXCEPTION;

function to_words(
p_amount number
) return varchar2;

function spell_number(
p_number in number
) return varchar2;
END spell_number_pkg;

CREATE OR REPLACE PACKAGE BODY spell_number_pkg
IS
/*
Spell Number in Indonesia and English
*/
–*******************************************************************
–* PRIVATE MEMBERS
TYPE varchar2_tbl_t IS TABLE OF VARCHAR2 (30);

FUNCTION to_hundredth_words (p_amount NUMBER)
RETURN VARCHAR2
IS
l_translate_groups   varchar2_tbl_t
:= varchar2_tbl_t (‘SATU’,
‘DUA’,
‘TIGA’,
‘EMPAT’,
‘LIMA’,
‘ENAM’,
‘TUJUH’,
‘DELAPAN’,
‘SEMBILAN’
);
l_tenth_groups       varchar2_tbl_t
:= varchar2_tbl_t (”, ‘PULUH’, ‘RATUS’);
l_char               VARCHAR2 (3);
l_length             NUMBER;
l_number             NUMBER;
l_words              VARCHAR2 (2000);
BEGIN
l_char := TO_CHAR (p_amount);
l_length := LENGTH (l_char);

FOR i IN 1 .. l_length
LOOP
l_number := TO_NUMBER (SUBSTR (l_char, l_length + 1 – i, 1));

IF (l_number != 0)
THEN
l_words :=
l_translate_groups (l_number)
|| RTRIM (‘ ‘ || l_tenth_groups (i))
|| RTRIM (‘ ‘ || l_words);
END IF;
END LOOP;

IF (l_words IS NOT NULL)
THEN
l_words := REPLACE (l_words, ‘SATU RATUS’, ‘SERATUS’);
l_words := REPLACE (l_words, ‘SATU PULUH SATU’, ‘SEBELAS’);
l_words := REPLACE (l_words, ‘SATU PULUH’, ‘SEPULUH’);
l_words := REPLACE (l_words, ‘SEPULUH DUA’, ‘DUA BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH TIGA’, ‘TIGA BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH EMPAT’, ‘EMPAT BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH LIMA’, ‘LIMA BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH ENAM’, ‘ENAM BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH TUJUH’, ‘TUJUH BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH DELAPAN’, ‘DELAPAN BELAS’);
l_words := REPLACE (l_words, ‘SEPULUH SEMBILAN’, ‘SEMBILAN BELAS’);
END IF;

RETURN l_words;
END to_hundredth_words;

–**********************************************************
–* PUBLIC MEMBERS
FUNCTION to_words (p_amount NUMBER)
RETURN VARCHAR2
IS
l_thousandth_groups   varchar2_tbl_t
:= varchar2_tbl_t (”, ‘RIBU’, ‘JUTA’, ‘MILIAR’, ‘TRILIUN’);
l_idx                 NUMBER          := 1;
l_amount              NUMBER;
l_fraction            NUMBER;
l_hundredth_words     VARCHAR2 (240);
l_words               VARCHAR2 (2000);
BEGIN
l_amount := TRUNC (ABS (p_amount));

IF (LENGTH (TO_CHAR (l_amount)) > 3 * l_thousandth_groups.COUNT)
THEN
RAISE amount_exceeds_limit;
END IF;

l_fraction := ABS (ROUND (p_amount, 2)) – l_amount;

LOOP
l_hundredth_words :=
to_hundredth_words (l_amount – TRUNC (l_amount, -3));

IF (l_hundredth_words IS NOT NULL)
THEN
l_words :=
l_hundredth_words
|| RTRIM (‘ ‘ || l_thousandth_groups (l_idx))
|| RTRIM (‘ ‘ || l_words);
END IF;

l_amount := TRUNC (l_amount, -3) / 1000;
EXIT WHEN l_amount = 0;
l_idx := l_idx + 1;
END LOOP;

IF (SUBSTR (l_words, 1, 9) = ‘SATU RIBU’)
THEN
l_words := ‘SERIBU’ || SUBSTR (l_words, 10);
END IF;

l_words := l_words;

IF (l_fraction != 0)
THEN
l_words :=
l_words || ‘ ‘ || to_hundredth_words (l_fraction * 100)
|| ‘ SEN’;
END IF;

RETURN l_words;
END to_words;

CREATE OR REPLACE FUNCTION spell_number (p_number IN NUMBER)
RETURN VARCHAR2
AS
TYPE myarray IS TABLE OF VARCHAR2 (255);

l_str      myarray
:= myarray (”,
‘ thousand ‘,
‘ million ‘,
‘ billion ‘,
‘ trillion ‘,
‘ quadrillion ‘,
‘ quintillion ‘,
‘ sextillion ‘,
‘ septillion ‘,
‘ octillion ‘,
‘ nonillion ‘,
‘ decillion ‘,
‘ undecillion ‘,
‘ duodecillion ‘
);
l_num      VARCHAR2 (50)   DEFAULT TRUNC (p_number);
l_return   VARCHAR2 (4000);
BEGIN
FOR i IN 1 .. l_str.COUNT
LOOP
EXIT WHEN l_num IS NULL;

IF (TO_NUMBER (SUBSTR (l_num, LENGTH (l_num) – 2, 3)) <> 0)
THEN
l_return :=
TO_CHAR (TO_DATE (SUBSTR (l_num, LENGTH (l_num) – 2, 3), ‘J’),
‘Jsp’
)
|| l_str (i)
|| l_return;
END IF;

l_num := SUBSTR (l_num, 1, LENGTH (l_num) – 3);
END LOOP;

RETURN l_return;
END spell_number;
END spell_number_pkg;
/

The cursor FOR UPDATE clause is only used with a cursor when you want to update tables in the database. Generally, when you execute a SELECT statement, you are not locking any rows. The purpose of using the FOR UPDATE clause is to lock the rows of the tables that you want to update, so that another user cannot perform an update until you perform your update and release the lock. The next COMMIT or ROLLBACK statement releases the lock. The FOR UPDATE clause will change the manner in which the cursor operates in only a few respects. When you open a cursor, all rows that meet the restriction criteria are identified as part of the active set. Using the FOR UPDATE clause will lock these rows that have been identified in the active set. If the FOR UPDATE clause is used, then rows may not be fetched from the cursor until a COMMIT has been issued. It is important for you to consider where to place the COMMIT.

The syntax is simply to add FOR UPDATE to the end of the cursor definition. If there are multiple items being selected, but you only want to lock one of them, then end the cursor definition with the following syntax:

FOR UPDATE OF <item_name>   Example:

DECLARE

  CURSOR c_course IS

     SELECT course_no, cost

       FROM course FOR UPDATE;

BEGIN

   FOR r_course IN c_course

   LOOP

      IF r_course.cost < 2500

      THEN

         UPDATE course

            SET cost = r_course.cost + 10

          WHERE course_no = r_course.course_no;

      END IF;

   END LOOP;

END;

This example shows how to update the cost of all courses with a cost under $2500. It will increment them by 10.

Answer: Placing a COMMIT after each update can be costly. But if there are a lot of updates and the COMMIT comes after the block loop, then there is a risk of a rollback segment not being large enough. Normally, the COMMIT would go after the loop, except when the transaction count is high, and then you might want to code something that does a COMMIT for each 10,000 records. If this were part of a large procedure, you may want to put a SAVEPOINT after the loop. Then, if you need to rollback this update at a later point, it would be an easy task.

PL/SQL sends SQL statements such as DML and queries to the SQL engine for execution, and SQL returns the result data to PL/SQL. You can minimize the performance overhead of this communication between PL/SQL and SQL by using the PL/SQL language features known collectively as bulk SQL. The FORALL statement sends INSERT, UPDATE, or DELETE statements in batches, rather than one at a time. The BULK COLLECT clause brings back batches of results from SQL. If the DML statement affects four or more database rows, the use of bulk SQL can improve performance considerably.

• Using the FORALL Statement, the keyword FORALL lets you run multiple DML statements very efficiently. It can only repeat a single DML statement, unlike a general-purpose FOR loop.
  The following example loads some data into PL/SQL collections. Then it inserts the
  collection elements into a database table twice: first using a FOR loop, then using a
  FORALL statement. The FORALL version is much faster.
  
  
• Retrieving Query Results into Collections with the BULK COLLECT Clause, using the keywords BULK COLLECT with a query is a very efficient way to retrieve the result set. Instead of looping through each row, you store the results in one or more collections, in a single operation. You can use these keywords in the SELECT INTO and FETCH INTO statements, and the RETURNING INTO clause.With the BULK COLLECT clause, all the variables in the INTO list must be collections. The table columns can hold scalar or composite values, including object types. The following example loads two entire database columns into nested tables:

source: PL/SQL User’s Guide and Reference 10g Release 1 (10.1)

Only INSERT, UPDATE, and DELETE statements can have output bind variables. You bulk-bind them with the RETURNING BULK COLLECT INTO clause of EXECUTE IMMEDIATE. With this clause, you can see which data have been inserted, updated or deleted.

Example:

Bulk SQL passes entire collections back and forth, not just individual elements. This technique improves performance by minimizing the number of context switches between the PL/SQL and SQL engines. You can use a single statement instead of aloop that issues a SQL statement in every iteration.

Bulk binding lets Oracle bind a variable in a SQL statement to a collection of values. The collection type can be any PL/SQL collection type (index-by table, nested table, or varray). The collection elements must have a SQL datatype such as CHAR, DATE, or NUMBER.
You can bind define variables in a dynamic query using the BULK COLLECT INTO clause. As the following example shows, you can use that clause in a bulk FETCH or bulk EXECUTE IMMEDIATE statement:

The SQL language has long offered the ability to apply set operations (UNION, INTERSECT, and MINUS) to the result sets of queries. In Oracle Database 10g, you can now use those same high-level, very powerful operators against nested tables (and only nested tables) in your PL/SQL programs and on nested tables declared as columns inside relational tables.

Nested Table Function:

• MULTISET UNION, all elements in both nested table x and nested table y are returned. If tables x and y are both empty then the returned table will be empty.
• MULTISET INTERSECT, elements in nested table x that also appear in nested table y are returned. If tables x and y have no common elements the returned table will be empty.
• MULTISET EXCEPT, elements in nested table x that do not appear in nested table y are returned. If table x has no elements that are not in table y the returned table will be empty.
• SUBMULTISET OF and NOT SUBMULTISET OF compare two nested tables to determine if all elements in the first nested table also appear in second nested table. This function returns a Boolean value TRUE, FALSE or NULL. The key word OF is optional.

The DISTINCT keyword in nested table function (MULTISET UNION, MULTISET INTERSECT, MULTISET EXCEPT) eliminates duplicate elements from the results. Nested table x, y and the returned table must all be of the same type. If either x or y is null, then the returned table is null.

Assigning a value to a collection element can cause various exceptions:

• If the subscript is null or is not convertible to the right datatype, PL/SQL raises the predefined exception VALUE_ERROR. Usually, the subscript must be an integer. Associative arrays can also be declared to have VARCHAR2 subscripts.
• If the subscript refers to an uninitialized element, PL/SQL raises SUBSCRIPT_BEYOND_COUNT.
• If the collection is atomically null, PL/SQL raises COLLECTION_IS_NULL (Refence to uninitialized collection).

If you want to exit from any enclosing loop, but not just the current loop, you can label the enclosing loop and use the label in an EXIT statement.

<<outer>>
FOR i IN 1..5 LOOP
. . . . .
FOR j IN 1..10 LOOP
. . . . .
EXIT outer WHEN . . . .
. . . . .
END LOOP;
END LOOP outer;
. . . . .