This is the working fix for the issue.

Solution-1:

1) Take backup of jvm.dll located at c:\Program Files\Oracle\JInitiator 1.3.1.21\bin\hotspot directory.
2) Copy jvm.dll from C:\Program Files\Java\jre1.6.0_07\bin\client (or whichever highest version of jre you have) to c:\Program Files\Oracle\JInitiator 1.3.1.21\bin\hotspot
3) Clear browser cache and also Oracle Jar cache (Remove all files from c:\documents and settings\<username>\Oralce Jar cache)
4) Close all the browsers and restart

Enjoy !! The issue should have been resolved now !

Solution-2:

In case if you are unable to find the jvm.dll in that location or if the above solution didn’t work for you, you can download the working jvm.dll from this link.

General Notes:
1. Before practicing using this vi tutorial, type the following command followed by a   carriage return: :set showmode
2. vi is not VI. It is case sensitive!!! So make sure Caps Lock is OFF.

Requirements:

In order to work correctly the vi need correct terminal type (TERM) setting. The TERM setting depends on the type of terminal you have. Commonly used TERM types are vt100, vt220 and ANSI.  In most cases vt100 will work fine. In case vi is not able to understand the TERM you have given, it starts in open mode giving you a line by line display. Generally TERM is taken from .profile or /etc/profile, but can be set at the command line as:

$TERM=vt100

$export TERM

echo $TERM will display the current TERM set.

Starting and Ending VI

Determining Line Numbers

Modes

Inserting, appending and replacing Text

Motion

Deleting Text

Yanking Text

Changing text

Putting text

Buffers

Markers

Search for strings

Replace

Regular Expressions

Counts

Ranges

Shell Functions

Files

VI Settings

Key Mapping

Other

The following format is used for commands:
Italic indicates a variable that you supply
Bold indicates exactly what you type
[ ] Square brackets indicate that the thing which they surround is optionally typed. The square brackets themselves are not to be typed.

To display a command description from the Unix Manual and can be used to get more information on each command. Type following on shell prompt to see the manual:
man command
Example: man ls to find more about the command ls

If you are not sure of the exact command name, you can use man with the -k option to help you find the command you need. To see one line summaries of each reference page that contains the keyword you specify, enter: man -k keyword

Converting DOS commands to UNIX commands

There are a few command line questions that are asked very often. These questions, with answers that should be typed at your shell prompt are printed below:

DOS                 UNIX
dir ............... ls
cls ............... clear
del ............... rm
copy .............. cp
move / rename ..... mv
type .............. cat
cd ................ cd
more < file ....... more file
md ................ mkdir
rd ................ rmdir
win ............... startx
(Note:  Unlike DOS, commands and their arguments MUST be separated by a space. 
For example, "cd/" doesn't work, but "cd /" does.)

Redirection

Pipes and redirection

command < file

Use the contents of file as the input for command

command > file

Send the output of command to file

command >> file

Append the output of command to the end of file

command1 | command2

Use the output of command1 as the input of command2 This is the Unix “pipe”. The “|” is called the “pipe” symbol.

Wildcards used in filenames

Control codes

Daemon Process

In Unix and other computer multitasking operating systems, a daemon is a computer program that runs in the background, rather than under the direct control of a user; they are usually initiated as background processes. Typically daemons have names that end with the letter “d”: for example, syslogd, the daemon that handles the system log, or sshd, which handles incoming SSH connections.

In a Unix environment, the parent process of a daemon is often (but not always) the init process (PID=1). Processes usually become daemons by forking a child process and then having their parent process immediately exit, thus causing init to adopt the child process. This is a somewhat simplified view of the process as other operations are generally performed, such as disassociating the daemon process from any controlling tty. Convenience routines such as daemon(3) exist in some UNIX systems for that purpose.

Systems often start (or “launch”) daemons at boot time: they often serve the function of responding to network requests, hardware activity, or other programs by performing some task. Daemons can also configure hardware (like devfsd on some Linux systems), run scheduled tasks (like cron), and perform a variety of other tasks.

Types of daemons

In a strictly technical sense, a Unix-like system process is a daemon when its parent process terminates and is therefore ‘adopted’ by the init process (process number 1) as its parent process and has no controlling terminal. However, more commonly, a daemon may be any background process, whether a child of init or not.

The common method for a process to become a daemon involves:

• Disassociating from the controlling tty
• Becoming a session leader
• Becoming a process group leader
• Staying in the background by forking and exiting (once or twice). This is required sometimes for the process to become a session leader. It also allows the parent process to continue its normal execution. This idiom is sometimes summarized with the phrase “fork off and die”
• Setting the root directory (“/”) as the current working directory so that the process will not keep any directory in use that may be on a mounted file system (allowing it to be unmounted).
• Changing the umask to 0 to allow open(), creat(), et al. calls to provide their own permission masks and not to depend on the umask of the caller
• Closing all inherited open files at the time of execution that are left open by the parent process, including file descriptors 0, 1 and 2 (stdin, stdout, stderr). Required files will be opened later.
• Using a logfile, the console, or /dev/null as stdin, stdout, and stderr

This is a list of Unix daemons that are found on various flavors of Unix. Unix daemons will typically consist of an abbreviation ending with a d. The current state of these processes can be listed with the full-output option of the process status (ps) command.

System Security

The following mechanism is the ONLY guaranteed method of protecting your work.

Each file and directory is owned by a user, and each user belongs to a group. By default, users own their home directory (the current directory when the user logs in) and the contents of the home directory. Most other files and directories are owned by “root” and other special users. The user assigns a type of privilege to each file and directory owned by the user. By default, the privilege is rwxr-xr-x.

The first three characters of rwxr-xr-x indicate that the owner can read, write, and execute the file (or directory). The middle three characters indicate that all other users in the same group as the owner can read and execute the file (or directory), but cannot write onto the file (or directory), as indicated by the middle “-” character. The last three characters indicate that everyone else on the system can read and execute the file (or directory), but cannot write onto the file (or directory), as indicated by the last “-” character.

To change the owner’s permissions of a file (or directory), the owner can type:

chown u+r file.1   chown u+w file.1   chown u+x file.1

chown u-r file.1   chown u-w file.1   chown u-x file.1

To change the group’s permissions of a file (or directory), the owner can type:

chown g+r file.1   chown g+w file.1   chown g+x file.1

chown g-r file.1   chown g-w file.1   chown g-x file.1

To change the permissions of a file (or directory) for everyone else, the owner can type:

chown o+r file.1   chown o+w file.1   chown o+x file.1

chown o-r file.1   chown o-w file.1   chown o-x file.1

Typing Shortcuts

• file* specifies all files and sub-directories that start with “file” and have 0 or more extra characters. *file* specifies all files and sub-directories that contain the string “file” anywhere in their name. fi*le specifies all files and sub-directories that start with “fi” and end with “le”, with 0 or more extra characters.
• file? specifies all files and sub-directories that start with “file” and have one extra character.
• The current directory can be specified as “.”, and the parent directory of the current directory can be specified as “..”. For example, if the current directory is /usr/people/mpagel, I can copy the file /usr/people/huffman/Crambin.pdb to /usr/people/mpagel/pdb/ by typing:

     cp  ../huffman/Crambin.pdb  ./pdb/

• Text on the screen can be highlighted by sweeping the mouse cursor over the text while pressing and holding the left mouse button. This text can be inserted at the command line by clicking the center mouse button, regardless of the mouse cursor position (as long as the mouse cursor remains in the window).
• If you type the first part of the name of a file or sub-directory in the current directory and then hit the <Esc> escape key, the workstation will complete the name for you. For example, if the current directory contains the files template.001 and temporary.stuff, then I can type:
  more templ<Esc>
  and the workstation will complete the name template.001. Note that if I type:
  more temp<Esc>
  then the workstation will NOT complete the file name, since I have not specified enough characters to unambiguously specify template.001 instead of temporary.stuff.
• history Shows list of last 100 commands

!! Repeats last command

!32 Repeats command #32 in the history list

!mor Repeats last command starting with “mor”

•·         If I type mv file.1 dir.1 to move file.1 to dir.1, then I can move file.2 to dir.1 by typing ^1^2, which does the following command: mv file.2 dir.1. Note that the only the first “1″ (in file.1) changes, and the “1″ in dir.1 does NOT change.

•·         Many commands have ‘modifiers’. For example, ls -l has a modifier “-l” which specifies that the LONG listing of the directory contents should be printed. Many modifiers can be combined in any order in one command. For example ls -la specifies the LONG listing of ALL directory contents.

•·         The “|” character is called the PIPE character. This character is located on the key just above the <Enter> key on the SGI keyboard (you must also hold down the <shift> key). The pipe character is used to direct the output of one command into the input of a second command. For example,

ps -ef | grep biosym
first creates a list of processes (ps -ef) and then filters this list to show all lines that contain “biosym” (grep biosym).

Oracle PL/SQL Quick Reference

PL/SQL Block Structure

• Scalar
• Composite
• Reference
• LOB(Large OBjects)

• Used to pass run time values out of the PL/SQL block back to the Host environment

SELECT Query Statement

SELECT [DISTINCT] {*, column [alias],…}

FROM table

WHERE condition(s)]

ORDER BY {column, exp, alias} [ASC|DESC]]

NOTE:

Avoid using DISTINCT with large table as it first does sorting of all the rows and then eliminates duplicate rows, so need a full table scan and thus it’s very slow.

ORDER BY is the last clause to get executed and thus could see all the column aliases; You can sort by a columns that is not in SELECT list; Default sorting order is Ascending (ASC)

Joins

Oracle proprietary syntax for version 8i and earlier

Cartesian Product

SELECT table1.*, table2.*,[...]

FROM table1,table2[,...]

Equijoin(Simple joins or inner join)

SELECT table1.*,table2.*

FROM table1,table2

WHERE table1.column = table2.column

Non-Equijoin

SELECT table1.*, table2.*

FROM table1, table2

WHERE table1.column

BETWEEN table2.column1 AND table2.column2

Outer join

SELECT table1.*,table2.*

FROM table1,table2

WHERE table1.column(+) = table2.column

SELECT table1.*,table2.*

FROM table1,table2

WHERE table1.column = table2.column(+)

Self join

SELECT alias1.*,alias2.*

FROM table1 alias1,table1 alias2

WHERE alias1.column = alias2.column

SQL: 1999 compliant syntax for version 9i

SELECT table1.column, table2.column

FROM table1

[CROSS JOIN table2] |

[NATURAL JOIN table2] |

[JOIN table2 USING (column_name)] |

[JOIN table2

ON (table1.column_name=table2.column_name)] |

[LEFT|RIGHT|FULL OUTER JOIN table2

ON (table1.column_name=table2.column_name)];

Aggregation Selecting

SELECT [column,] group_function(column),…

FROM table

[WHERE condition]

[GROUP BY group_by_expression]

[HAVING group_condition]

[ORDER BY column];

Group function

AVG([DISTINCT|ALL]n)

COUNT(*|[DISTINCT|ALL]expr)

MAX([DISTINCT|ALL]expr)

MIN([DISTINCT|ALL]expr)

STDDEV([DISTINCT|ALL]n)

SUM([DISTINCT|ALL]n)

VARIANCE([DISTINCT|ALL]n)

NOTE:

All columns in the SELECT list that are not in group functions must be in the GROUP BY clause; but GROUP BY column does not have to be in the SELECT list.

You can not use group functions in the WHERE clause;You use the HAVING clause to restrict groups.

All group functions except count(*) ignores null values. The NVL function forces group functions to include null values.

Subquery

SELECT select_list

FROM table

WHERE expr operator(SELECT    select_list

FROM      table);

NOTE:

The subquery(inner query) executes once before the main query

The result of the subquery is used by the main query(outer query)

The ORDER BY clause in the subquery is not needed unless you are performing TOP-N analysis.

single-row comparison operators: Return only one row

=        >     >=    <     <=    <>

multiple-row comparison operators: Return more than one row

IN         ANY             ALL

Multiple-column Subqueries

SELECT column, column, …

FROM table

WHERE (column, column, …) IN

(SELECT column, column, …

FROM table

WHERE condition);

Data Manipulation Statements (DML)

INSERT Statement(one row)

INSERT INTO table [ (column [,column...])]

VALUES (value [,value...]);

INSERT Statement with Subquery

INSERT INTO table [ column(, column) ]

subquery;

UPDATE Statement

UPDATE table

SET column = value [, column = value,...]

[WHERE condition];

Updating with Multiple-column Subquery

UPDATE table

SET (column, column,…) =

(SELECT column, column,…

FROM table

WHERE condition)

WHERE condition;

Deleting Rows with DELETE Statement

DELETE [FROM] table

[WHERE condition];

Deleting Rows Based on Another Table

DELETE FROM table

WHERE column = (SELECT column

FROM table

WHERE condition);

MERGE statement

MERGE INTO table_name table_aliase

USING (table|view|sub_query) alias

ON (join condition)

WHEN MATCHED THEN

UPDATE SET

col1 = col1_val,

col2 = col2_val

WHEN NOT MATCHED THEN

INSERT (column_list)

VALUES (column_values);

NOTE:

MERGE provides ability to conditionally update or insert data into a database table. It is useful in data warehousing applications. It avoids separate updates; increase performance and ease of use

Transaction Control Statements (TCL)

COMMIT;

SAVEPOINT name;

ROLLBACK [TO SAVEPOINT name];

Displaying table structure

DESC[RIBE] tablename

Data Definition Statemetns (DDL)

CREATE TABLE Statement

CREATE TABLE [schema.]table

(column datatype [DEFAULT expr] [,...]);

CREATE TABLE Statement with Subquery

CREATE TABLE [schema.]table

[(column, column...)]

AS subquery;

NOTE:

When a table is created using existing table except “NOT NULL” constraint, no other constraints are copied. If condition satisfied even rows are copied.

Datatype

VARCHAR2(size)    CHAR(size)        NUMBER(p,s)       DATE

LONG              CLOB              RAW               LONG RAW

BLOB              BFILE             ROWID

ALTER TABLE Statement

Adding columns

ALTER TABLE table_name

ADD (column datatype [DEFAULT expr]

[, column datatype]…);

Changing a column’s type, size and default value of a Table

ALTER TABLE table_name

MODIFY (column datatype [DEFAULT expr]

[, column datatype]…);

RENAMING table column: Supported by 9.2 and higher version only

ALTER TABLE table_name

RENAME column_name to new_column_name;

Dropping a column

ALTER TABLE table_name

DROP (column);

Dropping a Table

DROP TABLE table_name;

Changing the Name of an Object

RENAME old_name TO new_name;

Trancating a Table

TRUNCATE TABLE table_name;

Adding Comments to a Table

COMMENT ON TABLE table_name | COLUMN table.column

IS ‘text’;

Dropping a comment from a table

COMMENT ON TABLE table_name | COLUMN table.column IS ” ;

Data Dictionary

ALL_OBJECTS       USER_OBJECTS

ALL_TABLES        USER_TABLES

ALL_CATALOG       USER_CATALOG or CAT

ALL_COL_COMMENTS USER_COL_COMMENTS

ALL_TAB_COMMENTS USER_TAB_COMMENTS

Defining Constraints

CREATE TABLE [schema.]table

column datatype [DEFAULT expr][NOT NULL]

[column_constraint],…

[table_constraint][,...]);

Column constraint level

column [CONSTRAINT constraint_name] constraint_type,

Constraint_type

PRIMARY KEY REFERENCES table(column) UNIQUE

CHECK (condition)

Table constraint level(except NOT NULL)

column,…,[CONSTRAINT constraint_name]

constraint_type (column,…),

NOT NULL Constraint (Only Column Level)

CONSTRAINT table[_column...]_nn NOT NULL …

UNIQUE Key Constraint

CONSTRAINT table[_column..]_uk UNIQUE (column[,...])

PRIMARY Key Constraint

CONSTRAINT table[_column..]_pk PRIMARY (column[,...])

NOTE:

PRIMARY Key defined on more than column called ‘Composite Primary Key’ and to define composite primary key you need table level constraint as two columns are involved.

FOREIGN Key Constraint

CONSTRAINT table[_column..]_fk

FOREIGN KEY (column[,...])

REFERENCES table (column[,...])[ON DELETE CASCADE]

[ON DELETE SET NULL];

CHECK constraint

CONSTRAINT table[_column..]_ck CHECK (condition)

Adding a Constraint(except NOT NULL)

ALTER TABLE table_name

ADD [CONSTRAINT constraint_name ] type (column);

Adding a NOT NULL constraint

ALTER TABLE table_name

MODIFY (column datatype [DEFAULT expr]

[CONSTRAINT constraint_name_nn] NOT NULL);

Dropping a Constraint

ALTER TABLE table_name

DROP CONSTRAINT constraint_name;

ALTER TABLE table_name

DROP PRIMARY KEY | UNIQUE (column) |

CONSTRAINT constraint_name [CASCADE];

Disabling Constraints

ALTER TABLE table_name

DISABLE CONSTRAINT constraint_name [CASCADE];

Enabling Constraints

ALTER TABLE table_name

ENABLE CONSTRAINT constraint_name;

NOTE:

A UNIQUE or PRIMARY KEY index is automatically created if you enable a UNIQUE key or PRIMARY KEY constraint.

Data Dictionary

ALL_CONSTRAINTS        USER_CONSTRAINTS

ALL_CONS_COLUMNS        USER_CONS_COLUMNS

View

Creating or Modifying a View

CREATE [OR REPLACE] [FORCE|NOFORCE] VIEW view

[(alias[, alias]…)]

AS subquery

[WITH CHECK OPTION [CONSTRAINT constraint_name]]

[WITH READ ONLY [CONSTRAINT constraint_name]];

Top-N Analysis

SELECT [column_list], ROWNUM

FROM  (SELECT [column_list]

FROM table_name

ORDER BY Top-N_column)

WHERE ROWNUM <= N;

Removing a View

DROP VIEW view;

SEQUENCE

CREATE SEQUENCE Statement

CREATE SEQUENCE sequence

[INCREMENT BY n]

[START WITH n]

[{MAXVALUE n| NOMAXVALUE}]

[{MINVALUE n| NOMINVALUE}]

[{CYCLE | NOCYCLE}]

[{CACHE [n|20]| NOCACHE}];

Pseudocolumns

sequence.NEXTVAL        sequence.CURRVAL

Modifying a Sequence (No START WITH option)

ALTER SEQUENCE sequence

[INCREMENT BY n]

[{MAXVALUE n| NOMAXVALUE}]

[{MINVALUE n| NOMINVALUE}]

[{CYCLE | NOCYCLE}]

[{CACHE [n|20]| NOCACHE}];

Removing a Sequence

DROP SEQUENCE sequence;

Index

Creating an Index

CREATE INDEX index

ON TABLE (column[,column]…);

Removing an Index

DROP INDEX index;

Synoym

CREATE [PUBLIC] SYNONYM synonym

FOR object;

Removing Synonyms

DROP SYNONYM synonym;

Data Dictionary

ALL_VIEWS                     USER_VIEWS

ALL_SEQUENCES                 USER_SEQUENCES

ALL_INDEXES                   USER_INDEXES

ALL_IND_COLUMNS               USER_IND_COLUMNS

System Privileges (DBA)       User System Privileges

CREATE USER                   CREATE SESION

DROP USER                     CREATE TABLE

DROP ANY TABLE                CREATE SEQUENCE

BACKUP ANY TABLE              CREATE VIEW

CREATE PROCEDURE

Creating Users

CREATE USER user

IDENTIFIED BY password;

Creating Roles

CREATE ROLE role;

Granting System Privileges

GRANT privelges[,...] TO user[,...];

GRANT privelges TO role;

GRANT role TO user[,...];

Changing Password

ALTER USER user IDENTIFIED BY new_password;

Dropping Users

DROP USER user [CASCADE];

Dropping Roles

DROP ROLE role;

Object Privileges

Object      Table       View        Sequence          Procedure

ALTER         X                        X

DELETE        X          X

EXECUTE                                                  X

INDEX         X

INSERT        X          X

REFERENCES   X

SELECT        X          X             X

UPDATE        X          X

Object Privileges

GRAND object_priv [(column)]

ON object

TO {user|role|PUBLIC}

[WITH GRANT OPTION];

Revoking Object Privileges

REVOKE {privilege [,privilege...] | ALL}

ON object

FROM {user[,user...]|role|PUBLIC}

[CASCADE CONSTRAINTS];

Data Dictionary

ROLE_SYS_PRIVS

ROLE_TAB_PRIVS                USER_ROLE_PRIVS

USER_TAB_PRIVS_MADE           USER_TAB_PRIVS_RECD

USER_COL_PRIVS_MADE           USER_COL_PRIVS_RECD

Database Links

CREATE [PUBLIC] DATABASE LINK link_name

[CONNECT TO user_name IDENTIFIED BY password]

USING connection_string;

Single-Row Functions

Character Functions

LOWER(column|expression)

UPPER(column|expression)

INITCAP(column|expression)

INSTR(column|expression,m)

CONCAT(column1|expression1,column2|expression2}

SUBSTR(column|expression,m,[n])

LENGTH(column|expression)

LPAD(column|expression,n,’string’)

RPAD(column|expression,n,’string’)

TRIM(‘character’ FROM column|expression)

REPLACE(’string1′, ’string_to_replace’,[replacement_string])

Number Functions

MOD(m,n)

ROUND(column|expression,n)

TRUNC(column|expression,n)

Date Functions

MONTHS_BETWEEN(date1,date2)

ADD_MONTHS(date,n)

NEXT_DAY(date,’char’)

LAST_DAY(date)

ROUND(date[,'fmt'])

TRUNC(date[,'fmt'])

Arithmetic with Dates

• Add or subtract a number to or from a date for a resultant date value
• Subtract two dates to find the number of days between those dates
• Add hours to a date by dividing the number of hours by 24

Conversion Functions

TO_CHAR(number|date[,'fmt'])

TO_NUMBER(char[,'fmt'])

TO_DATE(char[,'fmt'])

NVL(expr1,expr2)

NVL2(expr1,expr2,expr3)

NULLIF(expr1,expr2)

COALESCE(expr1,expr2,…,exprn)

Conditional Expressions: Provide the use of IF-THEN-ELSE logic within a SQL statement.

DECODE(col|expr,search1,result1

[,search2,result2,...,]

[,default])

CASE expr WHEN comparision_expr1 THEN return_expr1

[WHEN comparision_expr2 THEN return_expr2

WHEN comparision_exprn THEN return_exprn

ELSE else_expr]

END

Nesting Functions

• Single-row functions can be nested to any level
• Nested functions are evaluated from deepest level to the least deep level
• In below example, functions F1, F2 and then F3 gets executed

F3(F2(F1(col,arg1),arg2),arg3)

Operators

Arithmetic        *     /     +     -

Comparison        =     >     >=    <     <=    <> or ^= or ~= or !=

BETWEEN…AND…, IN(set), LIKE, IS NULL

Concatenation     ||

Logical           AND   OR    NOT

Rules of Precedence

Order Evaluated         Operator

• 1 Arithmetic operators – multiplication and division(* /)
• 2 Arithmetic operators – Addition, subtraction and Concatenation operator ( + – || )
• 3 Comparison conditions
• 4 IS [NOT] NULL, LIKE, [NOT] IN
• 5 [NOT] BETWEEN
• 6 NOT logical condition; ** Exponentiation
• 7 AND logical condition
• 8 OR logical condition

Notes

• 1) Use ESCAPE identifier to search for the actual % and _ symbols (Here, % denotes zero or many characters and _ denotes one character in search condition )

Example: Get employee list having underscore (_) in last_name string

SELECT last_name

FROM EMPLOYEE

WHERE last_name LIKE ‘%\_%’ ESCAPE ‘\’;

• 2) DUAL is a dummy table you can use to view results from functions and calculations
• 3) SYSDATE is a function that returns: Date and Time
• 4) Inline view is a subquery with an alias that you can use within a SQL statement. A named subquery in the FROM clause of the main query is an example of an inline view. It is not a schema object.

consideration when writing an SQL statement is that it returns a correct result. The second is that it be the most efficient for a given situation.  You can use many different SQL statements to achieve the same result. It is often the case that only one statement will be the most efficient choice in a given situation.

Remember that processing SQL is a sequence of Parse (syntax check and object resolution), Execution (required reads and writes), and Fetch (row results retrieved, listed, sorted, and returned). SQL “tuning” consists, quite simply, of reducing one or more of them.

Note: generally Parse is the greatest time and resource hog. Parse overhead can be minimized by the use of Procedures, Functions, Packages, Views, etc.

Inadequate performance can have a significant cost impact on your business. A poor performing system and application can result in customer dissatisfaction, reduced productivity, and high costs. It is absolutely critical that the system’s performance is operating at its peak levels.

Following are some general tips that often increase SQL statement efficiency. Being general they may not apply to a particular scenario.

• Tuning SQL should only be done after your code is working correctly. Be aware that there is an inevitable tug-of-war between writing efficient SQL and understandable SQL.
• Ensure repeated SQL statements are writtenabsolutely identicallyto facilitate efficient reuse: re-parsing can often be avoided for each subsequent use of an identical statement.
  Writing best practices: all SQL verbs in upper-case i.e. SELECT; separate all words with a single space; all SQL verbs begin on a new line; SQL verbs aligned right or left within the initial verb; set and maintain a table alias standard; use table aliases and when a query involves more than one table prefix all column names with their aliases. Whatever you do, be consistent.
• o Use bind variables: The values of bind variables do not need to be the same for two statements to be considered identical. Bind variables are not substituted until a statement has been successfully parsed.
• o Use standard approach to table aliases. If two identical SQL statements vary because an identical table has two different aliases, then the SQL is different and will not be re-use or shared.
• o Use table aliases and prefix all column names by their aliases when more than one table is involved in a query. This reduces parse time and prevents future syntax errors if someone adds a column to one of the tables with same name as a column in another table. (ORA-00918: COLUMN AMBIGUOUSLY DEFINED)
• Code the query as simply as possible i.e. no unnecessary columns are selected, no unnecessary GROUP BY or ORDER BY.
  It is the same or faster to SELECT by actual column name(s). The larger the table the more likely the savings.
  Use:
  SELECT customer_id, last_name, first_name, street, city FROM customer;
  Rather than,
  SELECT * FROM customer;
• Beware of WHERE clauses which do not use indexes at all. Even if there is an index over a column that is referenced by a WHERE clause included in this section, Oracle will ignore the index. All these WHERE clause can be re-written to use an index while returning the same values. In other words, Do not perform operations on database objects referenced in the WHERE clause:
  Use:
  SELECT client, date, amount FROM sales WHERE amount > 0;
  Rather than:
  SELECT client, date, amount FROM sales WHERE amount != 0;
  ———————————————
  Use:
  SELECT account_name, trans_date, amount FROM transaction WHERE account_name LIKE ‘CAPITAL%’;
  Rather than:
  SELECT account_name, trans_date, amount FROM transaction WHERE SUBSTR(account_name,1,7)=‘CAPITAL’;
  ———————————————
  Use:
  SELECT account_name, trans_date, amount FROM transaction WHERE amount > 0;
  Rather than:
  SELECT account_name, trans_date, amount FROM transaction WHERE amount NOT=0;
  ———————————————
  Use:
  SELECT account_name, trans_date, amount FROM transaction WHERE amount < 2000;
  Rather than:
  SELECT account_name, trans_date, amount FROM transaction WHERE amount + 3000 < 5000;
  ———————————————
  Use:
  SELECT account_name, trans_date, amount FROM transaction WHERE account_name = ‘AMEX’ AND account_type = ‘A’;
  Rather than:
  SELECT account_name, trans_date, amount FROM transaction WHERE account_name|| account_type=‘AMEXA’;
• Don’t forget to tune views. Views are SELECT statements and can be tuned in just the same way as any other type of SLECT statement can be. All tuning applicable to any SQL statement are equally applicable to views.
• Avoid including a HAVING clause in SELECT statements. The HAVING clause filters selected rows only after all rows have been fetched. Using a WHERE clause helps reduce overheads in sorting, summing, etc. HAVING clauses should only be used when columns with summary operations applied to them are restricted by the clause.
  Use:
  SELECT city FROM country WHERE city!= ‘Vancouver’ AND city!= ‘Toronto’; GROUP BY city;
  Rather than:
  SELECT city FROM country GROUP BY city HAVING city!= ‘Vancouver’ AND city!= ‘Toronto’;
• Minimize the number of table lookups (subquery blocks) in queries, particularly if our statements include subquery SELECTs or multicolumn UPDATEs.
  Use:
  SELECT emp_name FROM emp WHERE (emp_cat, sal_range) = (SELECT MAX(category), MAX(sal_range) FROM emp_categories) AND emp_dept = 0020;
  Rather than:
  SELECT emp_name FROM emp WHERE emp_cat=(SELECT MAX(category) FROM emp_categories) AND emp_range = (SELECT MAX(sal_range) FROM emp_categories) AND emp_dept = 0020;
• When writing a sub-query (a SELECT statement within the WHERE or HAVING clause of another SQL statement):
• o Use a correlated (refers to at least one value from the outer query) sub-query when the return is relatively small and/or other criteria are efficient i.e. if the tables within the sub-query have efficient indexes.
• o Use a non-correlated (does not refer to the outer query) sub-query when dealing with large tables from which you expect a large return (many rows) and/or if the tables within the sub-query do not have efficient indexes.
• o Ensure that multiple sub-queries are in the most efficient order.
• o Remember that rewriting a sub-query as a join can sometimes increase efficiency.
• When doing multiple table joins consider the benefits/costs for each of EXISTS, IN, and table joins. Depending on your data one or another may be faster.
  Note: IN is usually the slowest.
  Note: When most of the filter criteria are in the sub-query IN may be more efficient; when most of the filter criteria are in the parent-query EXISTS may be more efficient.
  The following queries return the employee names from each department in department category ‘A’:
  SELECT emp_name FROM emp E WHERE EXISTS (SELECT ‘X’ FROM dept WHERE dept_no = E.dept_no AND dept_cat = ‘A’);
  ———————————————
  SELECT emp_name FROM emp E WHERE dept_no IN (SELECT dept_no FROM dept WHERE dept_no = E.dept_no AND dept_Cat = ‘A’);
  ———————————————
  SELECT emp_name FROM dept D, emp E WHERE E.dept_no = D.dept_no AND D.dept_cat = ‘A’;
• Where possible use EXISTS rather than DISTINCT, to avoid full table scan as DISTINCT operator causes Oracle to fetch all rows satisfying the table join and then sort and filter out duplicate values. EXISTS is a faster alternative, because the Oracle optimizer realizes when the subquery has been satisfied once, there is no need to proceed further and the next matching row can be fetched.
  Use:
  SELECT S.id, S.description FROM small_table S WHERE EXISTS (SELECT NULL FROM big_table B WHERE B.id = S.id);
  Rather than:
  SELECT DISTINCT S.id, S.description FROM small_table S, big_table B
  WHERE S.id = B.id;
• Where possible use a non-column expression (putting the column on one side of the operator and all the other values on the other). Non-column expressions are often processed earlier thereby speeding the query.
  Use:
  WHERE SALES < 1000/(1 + n);
  Rather than:
  WHERE SALES + (n * SALES) < 1000;
• Where possible use UNION ALL rather than using UNION. The UNION clause forces all rows retuned by each portion of the UNION to be sorted and merged and duplicates to be filtered out before the first row is returned. A UNION ALL simply returns all rows including duplicates and does not have to perform any sort, merge or filter. If your tables are mutually exclusive(include no duplicate records), or you don’t care if duplicates are returned, the UNION ALL is much more efficient.
  USE:
  SELECT acct_num, balance_amt FROM debit_transactions WHERE tran_date = ‘31-DEC-95′
  UNION ALL
  SELECT acct_num, balance_amt FROM credit_transactions WHERE tran_date = ‘31-DE -95′;
  Rather than:
  SELECT acct_num, balance_amt FROM debit_transactions WHERE tran_date = ‘31-DEC-95′
  UNION
  SELECT acct_num, balance_amt FROM credit_transactions WHERE tran_date = ‘31-DE -95′;
• Consider using DECODE to avoid having to scan the same rows repetitively or join the same table repetitively. Note, DECODE is not necessarily faster as it depends on your data and the complexity of the resulting query. Also, using DECODE requires you t change your code when new values are allowed in the field.
  USE:
  SELECT COUNT(DECODE(status,’Y',’X',NULL)) Y_count,
  COUNT(DECODE(status,’N',’X',NULL)) N_count
  FROM emp WHERE emp_name LIKE ‘SMITH%’;
  Raher than:
  SELECT COUNT(*) FROM emp WHERE status = ‘Y’ AND emp_name LIKE ‘SMITH%’;
  ———————
  SELECT COUNT(*) FROM emp WHERE status = ‘N’ AND emp_name LIKE ‘SMITH%’;
• Oracle automatically performs simple column type conversions(or casting) when it compares columns of different types. Depending on the type of conversion, indexes may not be used. Make sure you declare your program variables as the same type as your Oracle columns, if the type is supported in the programming language you are using.
  Use:
  SELECT emp_no, emp_name, sal FROM emp WHERE emp_no = ‘123′;
  HERE if emp_no indexed numeric, then after implicit conversion query will be:
  SELECT emp_no, emp_name, sal FROM emp WHERE emp_no = TO_NUMBER(‘123′);
  Thus, index is used in this case.
  Don’t use:
  SELECT emp_no, emp_name, sal FROM emp WHERE emp_type = 123;
  HERE if emp_type is indexed varchar2, then after implicit conversion query will be:
  SELECT emp_no, emp_name, sal FROM emp WHERE TO_NUMBER(emp_type) = 123;
  Thus, index will not be used in this case.
• The most efficient method for storing large binary objects, i.e. multimedia objects, is to place them in the file system and place a pointer in the DB.
• B-Tree Indexes do not store entries for NULL, so IS NULL is not indexable, but IS NOT NULL is indexable and thus if a huge table contains very few not null values then you should go for B-Tree indexes. On the other hand bitmap indexes support IS NULL condition.
  SELECT * FROM big WHERE status IS NOT NULL; (Use B-tree index in this case)
• Avoid using functions on indexed columns unless a function-based index is created; as it leads to full table scan even though index exists on the column.

Avoid using the following:

• Boolean operators >, <, >=, <=, IS NULL, IS NOT NULL
• NOT IN, !=
• Like ‘%pattern’, not exists
• Calculations on unindexed columns or (use union instead)
• Having (use a WHERE clause instead when appropriate)

Do use the following:

• Enable aliases to prefix all columns
• Place indexed columns higher in the WHERE clause
• Use SQL Joins instead of using sub-queries
• Make the table with the least number of rows, the driving table, by making it first in the FROM clause

Other important points for SQL Tuning

• Establish a tuning environment that reflects your production database
• Establish performance expectations before you begin
• Always Design and develop with performance in mind
• Create Indexes to support selective WHERE clauses and join conditions
• Use concatenated indexes where appropriate
• Consider indexing more than you think you should, to avoid table lookups
• Pick the best join method
• Nested loops joins are best for indexed joins of subsets
• Hash joins are usually the best choice for “big” joins
• Pick the best join order
• Pick the best “driving” table
• Eliminate rows as early as possible in the join order
• Use bind variables. Bind variables are key to application scalability
• Use Oracle hints where appropriate
• Compare performance between alternative syntax for your SQL statement
• Consider utilizing PL/SQL to overcome difficult SQL tuning issues
• Consider using third party tools to make the job of SQL tuning easier

Performing these steps is easy and provides a tremendous benefit and performance boost. Follow these simple steps and you can increase your system performance.

SQL*Plus is a command-line tool that provides access to the Oracle RDBMS.

SQL*Plus enables you to:

• Enter SQL*Plus commands to configure the SQL*Plus environment
• Startup and shutdown an Oracle database
• Connect to an Oracle database
• Enter and execute SQL commands and PL/SQL blocks
• Format and print query results

SQL*Plus is available on several platforms. In addition, it has a web-based user

interface, iSQL*Plus.

SQL*Plus is a client terminal software allowing users to interact with Oracle server to manipulate data and data structures. Users type in SQL statements in SQL*Plus that send statements to Oracle server. Oracle server then validates and executes the statements on its databases. The query results are returned to SQL*Plus and displayed to the user.  Besides sending SQL statements to the server, SQL*Plus also saves them into a local buffer and allow users to view and change the statements. The following figure illustrates the process.

After you login into SQL*Plus, at the SQL prompt, you can begin typing any SQL command. Upon hitting return (i.e., enter key) the SQL prompt will change to line number prompts. When you are finished typing a command, type / or RUN to execute the SQL command. Also, a semicolon at the end of the SQL command will execute the command immediately after hitting return. In addition to SQL commands, /, and RUN, you can also executes SQL*Plus file commands.

SQL*PLUS Commands Quick Reference

Below table shows, SQL*Plus commands available in the command-line interface. Not all commands or command parameters are shown.

SQL*Plus file command allow you to execute commands (or programs) stored in an external file, input or output data from/to a file, and save SQL commands typed during current session.

Some SQL*Plus file commands are:

• SAVE filename. This allows you to save buffer contents into a file.
• START filename. This allows you to execute a batch of SQL statements stored in a file.
• SPOOL filename. This allows you save SQL statements together with their outputs to a file.
• GET filename. This retrieve a file and places it into the buffer.
• @ filename. This allows you to execute a PL/SQL procedure(s) stored in a file.

Recall that the previously executed commands (in current SQL*Plus session) are stored in the local buffer. One way to change an SQL statement in the buffer is by using the line editor. The following are a list of line edit commands.

• LIST or L–Lists the contents of the buffer
• LIST n or L n–Lists the contents of line number n in the buffer and makes the line current
• LIST * or L *–Lists the current line
• LIST m n–Lists the range from m to n line
• Append text or A text–Adds to the end of the current line (e.g., “A ,” adds a comma to the end of line
• INPUT or I–Adds one or more lines after the current line so you can begin adding the text.
• CHANGE /text–Deletes text from the current line
• CHANGE /oldtext/newtext–Replaces oldtext with newtext in the current line
• DEL — Deletes the current line

Besides line editor, you can also use the vi editor if you are a fan of Unix editor!.

To invoke the vi editor, type Edit at the SQL Prompt.   Multiple SQL commands can be typed in vi editor. End each SQL command (except the last one) with a semicolon. After exiting notepad, type Start to run all of the commands.

Run SQL statements in a batch

To run SQL commands in a batch, you can put all your SQL commands into a text file and execute these commands in this file in SQL*PLUS.

• Use your favorite editor to type in your SQL queries into a text file.

For Example,

$ more table.sql
DROP TABLE employee
/

commit
/

CREATE TABLE employee (
empno INTEGER NOT NULL,
name VARCHAR2(50) NOT NULL,
sal REAL NOT NULL,
primary key (empno));
/

INSERT INTO employee VALUES (1, ‘Jack’, 6000);
INSERT INTO employee VALUES (2, ‘Tom’,  6000);
INSERT INTO employee VALUES (3, ‘John’, 6000);
INSERT INTO employee VALUES (4, ‘Jane’, 6000);
/

UPDATE employee SET sal=500 WHERE name=’Jack’
/

CREATE INDEX test_index on employee(sal)
/
$

• Connect into SQL*Plus, and run the batch of commands. For example, assume that you name the SQL file as table.sql.

SQL> START table.sql;

Output results

• You can record your SQL command outputs to a file for output or editing purpose.

SQL> SPOOL <your file name>

For example,

SQL> SPOOL myoutput.out

All SQL commands and their outputs after this command are written into the file myoutput.out that by default is stored in the current working directory where you invoked SQL*Plus.

• To end recording, use the following command:

SQL> SPOOL OFF

DUAL and select the current time

DUAL is the dummy table, mostly used to view the results from functions and calculations. The built-in function SYSDATE returns a DATE value containing the current date and time on your system. (Note Oracle is a client-server architecture and SQL*Plus is the client. SYSDATE gives you the time of the Unix system which you telnet in. It may NOT be the time of Oracle server unless you telnet into the machine running Oracle server.)

For example,

SQL> SELECT TO_CHAR(SYSDATE , 'Dy DD-Mon-YYYY HH24:MI:SS') as "Current Date/Time" FROM DUAL;;

Result:

Current Time

------------------------------------------------------------------------

Mon 15-July-2002 10:01:29

• TO_CHAR is a function to format a value.
• DUAL is built-in relation in Oracle which serves as a dummy relation to put in the FROM clause when nothing else is appropriate. For example, try “SELECT 2+2 FROM DUAL;”
• To format a number attribute to a dollar format, use the column <attribute> format <format>:

       SQL> COLUMN salary FORMAT $999,999

• To indicate the displayed width of a character string attribute, use the column <attribute> format <A’format>. For example, set the width of the name attribute to 8 characters.

       SQL> COLUMN name FORMAT A8

If a name is longer than 8 characters, the remaining is displayed at the second line (or several lines)

• The set command can be used to change the default number of lines per page (14) and the number of characters per line (80).

For example, to set the number of lines per page to 60, use the following command:

   SQL> SET PAGESIZE 60

• All formatting remain active until they are cleared or reset or after you exit from SQL*Plus.

   SQL> CLEAR COLUMN

• If you forget a specific SQL command you could enter

SQL> HELP <the SQL command>;

You could also find out all commands by entering:

SQL> HELP menu;

• Sometimes when you get something fuzzy, you  can try the following

SQL> SET SERVEROUTPUT ON
SQL> SET ARRAYSIZE 1

The Import and Export utilities work together; Export sends database definitions and actual data to an export file and Import can read the file to perform many different tasks. You can use Export and Import for many important database tasks, such as restoring a table, generating CREATE scripts, copying data among Oracle databases, migrating among Oracle versions, and moving tables from one schema to another.

Oracle’s export (exp) and import (imp) utilities are used to perform logical database backup and recovery. When exporting, database objects are dumped to a binary file which can then be imported into another Oracle database.

These utilities can be used to move data between different machines, databases or schema. However, as they use a proprietary binary file format, they can only be used between Oracle databases. One cannot export data and expect to import it into a non-Oracle database.

Various parameters are available to control what objects are exported or imported. To get a list of available parameters, run the exp or imp utilities with the help=yes parameter i.e. “exp help=yes” or “imp help=yes“.

The export/import utilities are commonly used to perform the following tasks:

• Back up and recover objects. Perhaps the most widely used Export and Import feature is the capability to serve as a useful backup solution. Most Oracle installations use full online or hot backups to back up the entire database in the event of a CPU, network, or disk failure. This works well because all data can be restored to the very millisecond that the database crashed. However, Export and Import provide for extra safety. If just one table in the entire database needs to be recovered during a full backup, the entire database would have to be recovered on another machine, and the one table would be copied back over into the original database. This incredibly time- and resource-consuming task could become a real headache in distributed databases. Export and Import can save you this trouble by exporting the entire database and importing just the tables that need to be recovered. Now that point-in-time recovery is an option for tablespaces in Oracle8, Export and Import can also serve as a backup and recovery mechanism for the entire database.
• Copy objects among schemas. You can use Export and Import to copy all object types such as tables, indexes, grants, procedures, and views from one schema to another. You can specify which objects you want to move, and provide the FROM and TO schemas. Oracle does the rest automatically.
• Copy objects among Oracle databases. You can export a table in one Oracle database and import that table into another. Many businesses export key tables and send the export files to a remote office location, which can then use Import to load the data into its local database. This is a form of one-way data replication to remote locations.
• Generate CREATE scripts. Export and Import contain powerful options that allow you to generate CREATE scripts for tables, partitions, indexes, object-type definitions, views, grants, constraints, rollback segments, tablespaces, and all other objects in the database. This safeguards the structure of your objects, in case one gets corrupted or deleted.
• Migrate databases from one Oracle version to another. You can upgrade (or downgrade) the version of Oracle by using the Export and Import utilities. For example, you can export an Oracle7 database, copy the export file to an Oracle8 database server, and then import into the Oracle8 server. This process, called migration, makes the data and application function in an Oracle8 environment. Of course, we always recommend complete testing before relying on the results of a migration.
• Defragment a tablespace. Fragmentation occurs when tables and indexes are created, dropped, enlarged, and reduced in size over time. Fragmentation also occurs when an object’s storage parameters are sized improperly. To defragment a tablespace, you can export a tablespace, coalesce the free space (or drop and recreate the tablespace), and import the objects again.

Because of the special binary format, files which had been created by the EXPORT utility can only be read by IMPORT. Both tools are only used to maintain ORACLE database objects.

SQL*Loader is similar to Import in that it can load data; the main difference is that Import can read only Oracle export files. SQL*Loader can read text files generated by non-Oracle databases.To load data from other systems into the database you have to use SQL*LOADER or other programs. To store data from database into readable operating system files you may use e.g. REPORTS, SQLPLUS.

While still supported on 10g the original import (imp) and export (exp) utilities were replaced in 10g with the faster and more advanced Data Pump-based import-export, impdp and expdp.

NOTE: It is generally advised not to use exports as the only means of backing-up a database. Physical backup methods (for example, when you use RMAN) are normally much quicker and supports point in time based recovery (apply archivelogs after recovering a database). Also, exp/imp is not practical for large database environments.

On 11g just imp will be still available, so if you using 10g, now is the time to starting using data pump.

Prerequisites/Requirements

exp and imp are utilities present in the $ORACLE_HOME/bin directory and are installed when Oracle is installed. Their prime purpose is to move logical objects out of and into the database respectively – for example dumping all of the tables owned by a user to a single file is achieved using the exp utility. It is important to distinguish between dumping data in this manner and backing up the database which is normally achieved using the rman utility.

$ORACLE_HOME, $ORACLE_SID and $PATH environment variables need to be set appropriately in a unix environment and the %ORACLE_SID% environment variable needs to be set in a windows environment, before executing these commands. If you login as the owner of the oracle software (usually the oracle user on unix) these are likely to have been set in the users profile. The Oracle Database instance needs to be up in order to export/import data. Type ‘imp help=y’ or ‘exp help=y’ for a detailed explanation of the available options for these utilities.

It is a prerequisite that oraenv or coraenv (if you are working in a c-shell) was executed before you export-import data. Consider, if you stored data in the database by using an national language support (NLS) other than AMERICAN you have to change your environment before import-export.
Example for a german environment:
NLS_LANG=GERMAN_GERMANY.WE8ISO8859P1
export NLS_LANG

In order to use exp and imp, the catexp.sql script must be run. catexp.sql basically creates the exp_full_database and imp_full_database roles. It is found under $ORACLE_HOME/rdbms/admin:

SQL> @?/rdbms/admin/catexp

catexp is called by catalog.sql. Note: SQL*Plus provides a shortcut to refer to the ORACLE_HOME directory: the question mark (?).

One must have the create session privilege for being able to use exp. If objects of another user’s schema need to be exported, the EXP_FULL_DATABASE role is required.

Before one imports rows into already populated tables, one needs to truncate or drop these tables to get rid of the old data. If not, the new data will be appended to the existing tables or it’ll get rejected. Either way, use the same syntax when you are ready to import the data. One must always DROP existing Sequences before re-importing. If the sequences are not dropped, they will generate numbers inconsistent with the rest of the database.

Note: It is also advisable to drop indexes before importing to speed up the import process. Indexes can easily be recreated after the data was successfully imported.

Control and Configure Export-Import
FULL, OWNER, and TABLE are the three types of exports. A FULL export exports all objects, structures, and data within the database for all schemas. OWNER exports only those objects owned by the specified user accounts. TABLE exports only the specified tables and partitions for specific user accounts.

Because dozens of object types can be exported, it’s important to distinguish what gets exported with each export category:

• With TABLE, the specified table (or cluster or partition) is exported with its indexes, referential integrity constraints, synonyms, and triggers.
• With OWNER specified, all the specified schema’s objects are exported. This includes database links, sequences, packages/procedures/functions, object-type definitions, clusters/tables/partitions, postable actions, synonyms, views, triggers, snapshots/snapshot logs, job queues, and refresh groups.
• With the FULL option, all objects described in OWNER are exported for every user account, in addition to tablespace definitions, profiles, user definitions (and encrypted passwords), roles, resource costs, rollback segment definitions, directory aliases, user history table, and auditing options.

You can use the Export and Import utilities in interactive or non-interactive mode. In interactive mode, Oracle steps you through the process, prompting for basic Import/Export session information. This method, however, limits you to the simple prompts that Oracle provides. You have more flexibility in non-interactive mode because you can supply up to 23 parameters for the Export utility and 24 parameters for the Import utility. The parameters may be supplied at the command line or by specifying a command file that contains all parameters and values. You can automate Export and Import sessions by using a command file, or repeat them over and over again manually.

The syntax of running Export and Import is as follows:
EXP KEYWORD=value or keyword=(value1,value2,…,valueN)
IMP KEYWORD=value or keyword=(value1,value2,…,valueN)
Replace KEYWORD with the parameter, and value with what should be the parameter’s value. For example, use the following to export the entire database:
EXP USERID=SYSTEM/MANAGER FULL=Y

Use the following to import the EMP and DEPT tables owned by the SCOTT user account: IMP USERID=SYSTEM/MANAGER FROMUSER=SCOTT TABLES=(EMP,DEPT)The following examples demonstrate how the imp/exp utilities can be used:
exp scott/tiger file=emp.dmp log=emp.log tables=emp rows=yes indexes=no
exp scott/tiger file=emp.dmp tables=(emp,dept)
imp scott/tiger file=emp.dmp full=yes
imp scott/tiger file=emp.dmp fromuser=scott touser=scott tables=dept

Using a parameter file:
exp userid=scott/tiger@orcl parfile=export.txt
… where export.txt contains:
BUFFER=100000
FILE=account.dmp
FULL=n
OWNER=scott
GRANTS=y
COMPRESS=y
NOTE: If you do not like command line utilities, you can import and export data with the “Schema Manager” GUI that ships with Oracle Enterprise Manager (OEM).
———————————————————————————–
The EXPORT utility may be used in three ways:

• Interactive dialogue
  Simply type exp. You will be prompted for your ORACLE userid, password. All other prompts answer by pressing the return key. This is the easiest way to export all data you stored in the ORACLE database. You may assign other values than the defaults to the parameters but in most cases it is unnecessary.
• Controlled through bypassed parameters
  You may bypass parameters when you export data from the database. Type:
  exp <userid/password> <parameter>=<value>,<parameter>=<value>,…
  Example of exporting scott’s tables EMP and DEPT to file empdept.expdat and storing all messages to file empdept.log:
  exp scott/tiger file=empdept.expdat tables=(EMP,DEPT) log=empdept.log
• Parameterfile controlled
  Instead of typing the parameters on the commandline you may use a parameter file where the parameters are stored. The syntax for this method is: exp <userid/password> parfile=<filename>

Do not ignore warnings and messages. Look at your logfile and repeat EXPORT until you get messages like:

About to export specified tables ...
. exporting table                            EMP       14 rows exported
. exporting table                           DEPT        4 rows exported
Export terminated successfully without warnings.
--------------------------------------------------------------------------------------
Like Export the Import utility is controlled by parameters. To get familiar with these parameters type: imp help=y
You will get a short description of usage and default settings of parameters.
To start IMPORT simply type imp. You will be prompted for your ORACLE userid, password. The next prompts depend on what you answer. In most cases you may answer the prompts by pressing the return key. But the following prompts you have to answer carefully.
Import file: expdat.dmp >
If your data was exported to file expdat.dmp press return, otherwise enter the filename where the exported data resides.
Ignore create error due to object existence (yes/no): yes >
This is a flag to indicate how object creation errors should be handeld. If you import into an existing table and you set IGNORE=Y, rows could be duplicated if they where already present in the table.
Import entire export file (yes/no): yes > no
Username:
If your exportfile consists of more objects than you want to import, enter no. In this case you will be prompted for the Username (this is normally your ORACLE account). Enter table names. Null list means all tables for user
Enter table name or . if done:
After entering the username you will be prompted for table names until you press the return key without entering a table name. Than IMPORT will be started.

Instead of the dialogue method you may use parameters. This is analogous to the methods described for EXPORT.
Examples:
imp <userid/password> tables=(table1,table2)
Tables table1, table2 will be imported from the default file export.dmp into the database.
imp <userid/password> parfile=<filename>
Import will be controlled by the named parameterfile.
After importing you should get messages like:

importing SCOTT's objects into SCOTT
. importing table "DEPT"                                     4 rows imported
. importing table "EMP"                                     14 rows imported
Import terminated successfully without warnings.
-----------------------------------------------------------------------------------

Parameters for the Export utility

Table below lists all parameters that can be used with the Export utility, along with their default values (if any).

How can you easily see the Export/Import parameters and syntax?

If you don’t have this book handy when necessary and haven’t memorized the dozens of parameters, the Export and Import utilities have a handy reference built in. Typing EXP HELP=Y or IMP HELP=Y at a command prompt brings up a nice one-page reference manual.

Parameter	Default Value	Description
INDEXES	Y	Specifies whether user-defined indexes are exported. System indexes created with constraints (primary key, unique key) and OID indexes are automatically exported, regardless of this parameter’s value.
LOG		Specifies the name of the file to spool the feedback from the export session. Unless otherwise specified, Oracle appends a .LOG extension to the file.
PARFILE		Rather than enter all parameters on the command line, some or all can be kept in a parameter file. This parameter specifies which file to use, if desired. This parameter is especially useful for non-interactive import sessions.
POINT_IN_TIME_RECOVER	N	Exports information for a point-in-time recovery for the tablespace listed with the TABLESPACES parameter.
RECORD	Y	If you use the INCTYPE parameter with RECORD=Y, the SYS data dictionary tables INCEXP, INCFIL, and INCVID are populated with export data such as owner, type of export, and the time of export.
RECORDLENGTH	OS-dependent	The RECORDLENGTH parameter is used only when you’ll import on a machine with a different byte count of the file than on the machine where the export occurs. The default should be used in most import sessions.
RECOVERY_TABLESPACES		Used with POINT_IN_TIME_RECOVER;specifies which tablespaces can be recovered by using point-in-time recovery. This is important because imports otherwise can’t recover transactions past the time of export.
ROWS	Y	Specifies whether table and object data will be exported. If ROWS=N, only object definitions are exported.
STATISTICS	ESTIMATE	Specifies whether table and index statistics are to be analyzed with COMPUTE or ESTIMATE when imported. Only those objects that already have statistics on them will be analyzed during import. Specify NONE if no objects should be analyzed.
TABLES		Specifies a comma-separated list of all tables to be exported. This parameter could be used with the OWNER parameter to specify which owner to associate the tables with. Tables can also be specified with the owner.table_name format. In a non-UNIX environment such as Windows NT, you must enclose the table list within parentheses.
TABLESPACES		List of tablespaces to be exported with the POINT_IN_TIME_RECOVER parameter.
USERID		Specifies the username and password for the user conducting the import. The format for the command is username/password. You can also use Net8’s @connect_string format if you want.

Parameters for the Import utility
You can use 24 parameters during an import session. They may be specified in the command line or any specified parameter file. Table below lists all the import parameters.

Export/Import and non-Oracle databases

The export file (expdat.dmp by default) is a binary file that only Oracle databases can read. Many databases and PC software can export data into delimited text files, but the Export utility can’t. To transfer data from Oracle to a non-Oracle database, you must make a delimited file manually by spooling from within PL/SQL or SQL*Plus and running a custom-made script.

Parameter	Default Value	Description
FILE	expdat.dmp	By default, expdat.dmp (stands for EXPort DATa.DuMP) is the name of the file that Import will import from. If the file is something other than expdat.dmp, specify it with this parameter.
FROMUSER		Specifying this parameter imports only those objects owned by the FROMUSER user account.
FULL	N	The entire database will be imported if FULL=Y.
GRANTS	Y	Specifies whether all grants will be created for the exported objects.
HELP	N	No other parameters are needed if you specify HELP=Y. A basic help screen will appear.
IGNORE	N	If IGNORE=Y, object creation errors are ignored, and records are inserted into the table. Duplicate records can result, if no unique constraints exist for the table. Non-object creation errors are still reported, such as operating system problems.
INCTYPE		If you’re importing an incremental export, tables are dropped and recreated. You must first restore from the last SYSTEM export (specify INCTYPE=SYSTEM). Then import every incremental export (specify INCTYPE=RESTORE) until the desired changes are applied to the database.
INDEXES	Y	Specifies whether user-defined indexes are imported. System indexes created with constraints (primary key, unique key) and OID indexes are automatically imported, regardless of this parameter’s value.
INDEXFILE		Specifies the name of the file to generate CREATE INDEX statements. Unless otherwise specified, Oracle appends an .SQL extension to the file. (This parameter is explained in more detail later in this chapter.)

Using the LOG parameter

You can specify a log file for the Export and Import sessions with the LOG parameter. The file, which mimics what’s output to the screen, reports all successful and unsuccessful messages to be examined at a later point. Some Oracle experts use this file during an automated load process and then checks the file for errors. A database administrator is paged if any appear.

Parameter	Default Value	Description
LOG		Specifies the name of the file to spool the feedback from the import session. Unless otherwise specified, Oracle appends an .LOG extension to the file.
PARFILE		Rather than enter all parameters on the command line, some or all may be kept in a parameter file. The PARFILE parameter specifies which file to use, if desired. This parameter is especially useful for non-interactive import sessions.
POINT_IN_TIME_RECOVER	N	Performs a point-in-time recovery for the tablespace exported with the TABLESPACES parameter.
RECORDLENGTH	OS-dependent	Used only when importing on a machine with a different byte count of the file than on the machine where the export occurred. The default should be used in most Import sessions.
SHOW	N	Displays each SQL statement and doesn’t apply them to the database. The SQL statements can be viewed and modified when used with the FILE parameter. (The SHOW parameter is explained in more detail later in this chapter.)
SKIP_UNUSABLE_INDEXES	N	Allows the postponement of index creation until the record data is imported. The indexes affected are only those set to an unusable state, and all other indexes are created if INDEXES=Y (the default value) is set.
TABLES		Specifies a comma-separated list of all tables to be imported. You should use this parameter with the FROMUSER parameter. In a non-UNIX environment, such as Windows NT, enclose the table list within parentheses.
TOUSER		Specifies the user account into which tables should be imported, if you want it to be different from the original owner of the tables. This parameter needs to be used with the FROMUSER parameter.
USERID		Specifies the username and password for the user conducting the import. The format for the command is username/password. You may also use Net8’s @connect_string format if desired.

————————————————————————————–Using imp/exp across different Oracle version

If exp and imp are used to export data from an Oracle database with a different version than the database in which is imported, then the following rules apply:

• 1. exp must be of the lower version
• 2. imp must match the target version

——————————————————————————————–Common Export/Import Errors

• ORA-00001: Unique constraint (…) violated
  You are importing duplicate rows. Use IGNORE=YES to skip tables that already exist (imp will give an error if the object is re-created) OR Perform the following actions:
• 1. Back up the target table.
• 2. Try deleting the target table.
• 3. Run the import for this table again in overwrite mode.
• ORA-01555: Snapshot too old
  Ask your users to STOP working while you are exporting or try using parameter CONSISTENT=NO
• ORA-01562: Failed to extend rollback segment
  Create bigger rollback segments or set parameter COMMIT=Y while importing
• IMP-00015: Statement failed … object already exists…
  Use the IGNORE=Y import parameter to ignore these errors, but be careful as you might end up with duplicate rows.

——————————————————————————————–
To Improve performance

Export

• Set the BUFFER parameter to a high value (e.g. 2Mb — entered as an integer “2000000″)
• Set the RECORDLENGTH parameter to a high value (e.g. 64Kb — entered as an integer “64000″)
• Use DIRECT=yes (direct mode export)
• Stop unnecessary applications to free-up resources for your job.
• If you run multiple export sessions, ensure they write to different physical disks.
• DO NOT export to an NFS mounted filesystem. It will take forever.

Import

• Create an indexfile so that you can create indexes AFTER you have imported data. Do this by setting INDEXFILE to a filename and then import. No data will be imported but a file containing index definitions will be created. You must edit this file afterwards and supply the passwords for the schemas on all CONNECT statements.
• Place the file to be imported on a separate physical disk from the oracle data files
• Increase DB_CACHE_SIZE (DB_BLOCK_BUFFERS prior to 9i) considerably in the init$SID.ora file
• Set the LOG_BUFFER to a big value and restart oracle.
• Stop redo log archiving if it is running (ALTER DATABASE NOARCHIVELOG;)
• Create a BIG tablespace with a BIG rollback segment inside. Set all other rollback segments offline (except the SYSTEM rollback segment of course). The rollback segment must be as big as your biggest table (I think?)
• Use COMMIT=N in the import parameter file if you can afford it
• Use STATISTICS=NONE in the import parameter file to avoid time consuming to import the statistics
• Remember to run the indexfile previously created

———————————————————————————————–
Good practices

• Always take care about CHARSETS when you do export and import. Using the wrong ones can convert your data in a lossy manner. The best situation is when your source and destination database have the same character sets, so you can avoid completely any character conversion. You control this behavior by setting NLS_LANG environment variable appropriately. When not set properly you may see ‘Exporting questionable statistics’ messages.
• After doing an export, it is better to check your dump by doing an import with the parameter SHOW=Y. This checks the validity of your dump file.

——————————————————————————————Other considerations

• You may need to patch your Oracle client (where you are running exp/imp) to the same level as the Oracle server to prevent errors
• When importing large amounts of data consider dropping indexes prior to the import to speed up the process and re-creating them once the import is completed
• The amount of archive logs that may be created on a large import may fill up your disk
• On INSERT triggers will fire, consider whether these need to be disabled
• Increasing the RECORDLENGTH (max 65535) parameter can improve the length of time to perform an import/export as well as DIRECT=y for export

——————————————————————————-
Tablespace fragmentation occurs when objects are created, dropped, enlarged, and shrunk. The more often this occurs, the more fragmented the tablespace becomes. This causes free space to be broken into many separated island-like chunks of space. In addition, if an object has multiple extents, they could be spread out over different parts of the tablespace; this causes performance and maintenance problems. With many small blocks of free space instead of fewer large free spaces, you may be unable to create some objects that you otherwise could have. By defragmenting the tablespace, the data is reorganized so that all free space is put into one contiguous area, and each object’s extents are grouped next to each other.

• The Export and Import utilities can fix fragmentation in two ways:
  They can take a table with multiple extents and resize it into a table with one larger extent. This larger single extent will encompass the total size of all previous table extents.
• They can make all objects within the tablespace adjacent to each other with no island-like characteristics, while at the same time merging all the free space into one larger free space.

The easiest and most dramatic method fixes both fragmentation problems for the entire database. The database is shut down during the process. This forces all sessions against the database to stop (which is why it’s the most dramatic method).

Fixing a table’s storage parameter is fairly easy compared to the entire tablespace, as only one table is affected. To fix an entire tablespace, you’ll have to drop and recreate it, along with all the tables within it.

Fix both fragmentation problems quickly

• Export the entire database, specifying FULL=Y and COMPRESS=Y. FULL=Y exports the entire database; COMPRESS=Y changes the INITIAL storage parameter of each table in the database (if necessary) to fit within one extent each. For example, if a table has five 10M extents, the COMPRESS=Y specification changes the table to one 50M extent when imported.
• Drop and recreate the entire database.
• Import the entire database with the FULL=Y parameter.

Defragment just one tablespace (a less dramatic method)

• Determine which tables exist in the tablespace and export just those tables.
• Drop all the tables in the tablespace.
• Issue the ALTER TABLESPACE COALESCE command (or drop and recreate the tablespace). This will coalesce all the free space within the tablespace into one contiguous area.
• Import the tables. Oracle will create the tables adjacent to each other within the tablespace, and all free space will still be contiguous in one chunk of space.

——————————————————————————-

Some more examples

EXP
To dump a single schema to disk (we use the scott example schema here)

- Login to server which has an Oracle client

exp <user>/<password> FILE=scott.dmp OWNER=scott
To export specific tables to disk: Login to server which has an Oracle client

exp SYSTEM/password FIlE=expdat.dmp TABLES=(scott.emp,hr.countries)

The above command uses two users : scott and hr

exp <user>/<password> FILE=scott.dmp TABLES=(emp,dept)

the above is only for one user : scott

IMP
To import the full database exported in the example above.
imp SYSTEM/password FULL=y FIlE=dba.dmp

To import just the dept and emp tables from the scott schema
imp SYSTEM/password FIlE=dba.dmp FROMUSER=scott TABLES=(dept,emp)

To import tables and change the owner

imp SYSTEM/password FROMUSER=blake TOUSER=scott FILE=blake.dmp TABLES=(unit,manager)
To import just the scott schema exported in the example above:
imp <user>/<password> FIlE=scott.dmp

If you do not supply any parameters then you enter an interactive session as illustrated below. (Responses to prompts are shown in blue. from the prompt type imp and press enter

$>imp
Import: Release 9.2.0.6.0 – Production on Thu Mar 29 15:07:43 2007
Copyright (c) 1982, 2002, Oracle Corporation. All rights reserved.
Username: SYSTEM
Password: password
Connected to: Oracle9i Enterprise Edition Release 9.2.0.6.0 – Production
With the Partitioning, OLAP and Oracle Data Mining options
JServer Release 9.2.0.6.0 – Production
Import file: expdat.dmp > /mention/path/of/dumpFile/includingFileName.dmp
Enter insert buffer size (minimum is 8192) 30720> (press enter to accept default)
Export file created by EXPORT:V09.02.00 via conventional path
import done in US7ASCII character set and AL16UTF16 NCHAR character set
import server uses AL32UTF8 character set (possible charset conversion)
List contents of import file only (yes/no): no > press enter
Ignore create error due to object existence (yes/no): no > press enter
Import grants (yes/no): yes > press enter
Import table data (yes/no): yes > press enter
Import entire export file (yes/no): no > press enter or type no
Username: give the userName for which you want the data to be imported
Enter table(T) or partition(T:P) names. Null list means all tables for user
Enter table(T) or partition(T:P) name or . if done: press enter
. importing TST_001_V2’s objects into TST_001_V2