Cause: Failed to allocate an extent of the required number of blocks for a temporary segment in the tablespace indicated.

Action: Use ALTER TABLESPACE ADD DATAFILE statement to add one or more files to the tablespace indicated.

MetaLink has a very detailed and informative article concerning ORA-01652 and RAC.  There is some troubleshooting required with ORA-01652 in RAC because there are two common causes in this area.

1. ORA-01652 may occur because there is simply no space available in the temp tablespace of which is being used.
2. ORA-01652 may have to do with the local temp segment not being able to extent space even though there is space in other instances.

To troubleshoot for ORA-01652,  and find out which of the above scenarios are causing ORA-01652 use this query offered by MetaLink:

select sum(free_blocks)
from gv$sort_segment
where tablespace_name = ‘<TEMP TABLESPACE NAME>’

You will know that the first scenario is causing ORA-01652 to be thrown if the free block reads ‘0′ because it signifies that there is no free space.

If there is a good amount of space, you know that there is another cause for ORA-01652, and it is probably the second scenario.  It is important to note that in a non-RAC environment, local instances are not able to extend the temp segments.

In sever cases, a slowdown may occur, in which you might want try one of the following work-arounds:

1. Increase size of the temp tablespace
2. Increase sort_area_size and/or pga_aggregate_target

If ORA-01652 is causing the slowdown, SMON will probably not be able to process the sort segment requests, you  should try to diagnose the contention:

• Output from the following query periodically during the problem:
  select inst_id, tablespace_name, total_blocks, used_blocks, free_blocks
  from gv$sort_segment;
• Global hang analyze and systemstate dumps

Reference: Oracle Error Tips by Burleson Consulting

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;
/

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;
. . . . .

NOCOPY is a hint to the compiler about how you would like the PL/SQL engine to work with the data structure being passed in as an OUT or IN OUT parameter. By default, OUT and IN OUT parameters are passed by value. The values of any IN OUT parameters are copied before the subprogram is executed. During subprogram execution, temporary variables hold the output parameter values. If the subprogram exits normally, these values are copied to the actual parameters. If the subprogram exits with an unhandled exception, the original parameters are unchanged.

When the parameters represent large data structures such as collections, records, and
instances of object types, this copying slows down execution and uses up memory. In
particular, this overhead applies to each call to an object method: temporary copies are
made of all the attributes, so that any changes made by the method are only applied if
the method exits normally.

To avoid this overhead, you can specify the NOCOPY hint, which allows the PL/SQL
compiler to pass OUT and IN OUT parameters by reference. If the subprogram exits
normally, the behavior is the same as normal. If the subprogram exits early with an
exception, the values of OUT and IN OUT parameters (or object attributes) might still
change. To use this technique, ensure that the subprogram handles all exceptions.
A call to the procedure that uses NOCOPY makes much less time.

DECLARE
TYPE EmpTabTyp IS TABLE OF emp%ROWTYPE;
emp_tab EmpTabTyp := EmpTabTyp(NULL); — initialize
t1 NUMBER;
t2 NUMBER;
t3 NUMBER;
PROCEDURE get_time (t OUT NUMBER) IS
BEGIN t := dbms_utility.get_time; END;
PROCEDURE do_nothing1 (tab IN OUT EmpTabTyp) IS
BEGIN NULL; END;
PROCEDURE do_nothing2 (tab IN OUT NOCOPY EmpTabTyp) IS
BEGIN NULL; END;
BEGIN
SELECT * INTO emp_tab(1) FROM emp where rownum <= 1;
emp_tab.EXTEND(49999, 1); — copy element 1 into 2..50000
get_time(t1);
do_nothing1(emp_tab); — pass IN OUT parameter
get_time(t2);
do_nothing2(emp_tab); — pass IN OUT NOCOPY parameter
get_time(t3);
dbms_output.put_line(‘Call Duration (secs)’);
dbms_output.put_line(‘——————–’);
dbms_output.put_line(‘Just IN OUT: ‘ || TO_CHAR((t2 – t1)/100.0));
dbms_output.put_line(‘With NOCOPY: ‘ || TO_CHAR((t3 – t2))/100.0);
END;

Result:
Call Duration (secs)
——————–
Just IN OUT: .22
With NOCOPY: 0

In the below example, we can suppress duplicate values in the MGR column, display a blank line between manager number groups, and suppress the display of repeated values in the DEPTNO column using the BREAK command.

SQL> BREAK ON mgr SKIP 1 ON deptno
when the query executes, the report output is organized based on the specifications you made in the BREAK command.