Data concurrency means that many users can access data at 
the same time.

Data consistency means that each user sees a consistent 
view of data including the transactions made by him as well 
as others.

WHERE  CURRENT OF clause in an UPDATE,DELETE statement 
refers to the latest row  fetched from a cursor.

WHERE CURRENT OF clause is used to update the current row of
the active set of a cursor

%sqlcount

User_Errors table
OR 
show error on sql promt.

SHOW ERROR will show the error code and message in a pl/sql
block.

If you know where exactly the error is then uses number of
dbms statements before/after each sql statement.

advantage :

In pl/sql if you want perform some actions more than one 
records you should user these cursors  only. By using these 
cursors you process the query records. you can easily move 
the records and  you can exit from procedure when you 
required by using cursor attributes.


disadvantage:

using implicit/explicit cursors are depended by Situation. 
If the result set is les than 50 or 100  records it is 
better to go for implicit cursors. if the result set is 
large then you should use exlicit  cursors. other wise it 
will put burdon on cpu.

Advantage:
Using cursors  we can retrieve multiple records in a plsq block.

Disadvantage:
switching between the plsql statement executor and sql
statement executor at plsql runtime engine will consume time.

Implicit Cursor are declared and used by the oracle 
internally. whereas the explicit cursors are  declared and 
used by the user.

more over implicitly cursors are no need to declare oracle 
creates  and process and closes autometically. the explicit 
cursor should be declared and closed by the  user.

More over Explicit Cursors were used to retrieve values 
from two or more rows.

The implicit cursor is used to process INSERT, UPDATE,
DELETE, and SELECT INTO statements. During the processing of
an implicit cursor,Oracle automatically performs the OPEN,
FETCH, and CLOSE operations.

Where as in explicit cursors,the process of its working is
done in 4 steps namely DECLARE a cursor,OPEN a cursor,
FETCH from cursor and CLOSE a cursor.

IMPLICT CURSOR:- Automatically porvide by oracle which 
perform DML statements. queries returns only one row.

EXPLICT CURSOR:- Defined by user. queries returns more 
than  rows.

Explicit Cursor:-We are not able to Handle NO_DATA_FOUND 
Exception.

Implicit Cursor:-We are able to Handle NO_DATA_FOUND 
Exception.

stored procedures are subprogrammes stored in the database 
and can be called & execute  multiple times where in an 
application procedure is the one being used for a 
particular application  same is the way for function.

Forward Declaration means.. If you are defining a package 
body having two procedures , If u  want to use second 
procedure in the defination of first procedure.

You have to declare the second  package with its arguments
(if have)  before using in the defination of first 
procedure.its labled as  forward declaration.

declaration first defination later is nothing but a forward 
declaration

As Distributed database system based on 2 phase commit,one 
query is independent of 2 nd  query so of course we can run.

You cannot store cursor variables in an associative array, 
nested table, or varray.Cursors and  cursor variables are 
not interoperable; 

that is, you cannot use one where the other is expected. 
For example, you cannot reference a cursor variable in a 
cursor FOR loop.

cursor variables are subject to the following 
restrictions:You cannot declare cursor variables in a 
package spec. For example, the following declaration is not 
allowed:CREATE PACKAGE emp_stuff AS TYPE EmpCurTyp IS REF 
CURSOR RETURN emp%ROWTYPE; emp_cv EmpCurTyp; -- not 
allowedEND emp_stuff;You cannot pass cursor variables to a 
procedure that is called through a database link.If you 
pass a host cursor variable to PL/SQL, you cannot fetch 
from it on the server side unless you also open it there on 
the same server call.You cannot use comparison operators to 
test cursor variables for equality, inequality, or 
nullity.You cannot assign nulls to a cursor 
variable.Database columns cannot store the values of cursor 
variables. There is no equivalent type to use in a CREATE 
TABLE statement.You cannot store cursor variables in an 
associative array, nested table, or varray.Cursors and 
cursor variables are not interoperable; that is, you cannot 
use one where the other is expected. For example, you 
cannot reference a cursor variable in a cursor FORloop

Export the higher version data using lower version Export 
utility and import it to the lower  version DB.

We Can Schedule The Procedure Run Automatically By Using  
Packages.

By using dbms_job (buitin package upto oracle 9i)
and using dbms_scheduler (oracle 10G onwrds)

Definer Rights
--------------

A routine stored in the database by default, is executed 
with the definer rights (owner of the  routine), depending 
on the user who calls it. 

For example, table "Test" belongs to schema A. User A 
creates a procedure PR_TEST allowing  for updates of a 
table. User B is granted execute privileges on the 
procedure. Now user B cannot access the table as no 
privileges have been granted, but can call the procedure to 
do the required  process logic for updating the table.

Invoker Right

-------------
With Oracle 8i, there is no need for this duplication of 
code. A single compiled program unit can be  made to use 
schema A's objects when invoked by User A and schema B's 
objects when invoked  by User B. 

This way, we have the option of creating a code repository 
in one place and sharing it with various production users. 
The owner of the routine must grant EXECUTE privilege to 
other  users.