• The performance of queries against the tables may improve because Oracle may have to search only one partition (one part of the table) instead of the entire table to resolve a query.
• The table may be easier to manage. Because the partitioned table’s data is stored in multiple parts, it may be easier to load and delete data in the partitions than in the large table.
• Backup and recovery operations may perform better. Because the partitions are smaller than the partitioned table, you may have more options for backing up and recovering the partitions than you would have for a single large table.

In Oracle we can partition a table by the following methods

Range Partitioning

Tables are partitioned by ranges of values.useful when dealing with data that has logical ranges into which it can be distributed.

eg:

create table Library
(      Title VARCHAR2(100) primary key,
Publisher VARCHAR2(20),
CategoryName VARCHAR2(20),
Rating VARCHAR2(2),
references CATEGORY(CategoryName)
)
partition by range (CategoryName)

table will be partitioned based on the values in the CategoryName

Hash Partitioning

A hash partition determines the physical placement of data by performing a hash function on the values of the partition key.In hash partitioning, consecutive values of the partition key are not generally stored in the same
partition. Hash partitioning distributes a set of records over a greater set of partitions than range partitioning does, potentially decreasing the likelihood for I/O contention.

To create a hash partition, use the partition by hash clause in place of partition by range

eg:

create table Library
(      Title VARCHAR2(100) primary key,
Publisher VARCHAR2(20),
CategoryName VARCHAR2(20),
Rating VARCHAR2(2),
references CATEGORY(CategoryName)
)
partition by hash (CategoryName)
partitions 16;

Use hash partitioning if your data does not easily lend itself to range partitioning, but you would like to partition for performance and manageability reasons.

List Partitioning

In list partitioning, you tell Oracle all the possible values and designate the partitions into which the corresponding rows should be inserted.

create table Library
(      Title VARCHAR2(100) primary key,
Publisher VARCHAR2(20),
CategoryName VARCHAR2(20),
Rating VARCHAR2(2),
references CATEGORY(CategoryName)
)
partition by list (CategoryName)

Creating Subpartitions

You can create subpartitions—that is, partitions of partitions. You can use subpartitions to combine all types of partitions: range partitions, list partitions, and hash partitions. For example, you can use hash partitions in combination with range partitions, creating hash partitions of the range
partitions. For very large tables, this composite partitioning may be an effective way of separating the data into manageable and tunable divisions.

Indexing Partitions

When you create a partitioned table, you should create an index on the table. The index may be partitioned according to the same range values used to partition the table. In the following listing,

create index index_library
on library(CategoryName)
local
(partition PART1
tablespace PART1_NDX_TS,
partition PART2
tablespace PART2_NDX_TS);

A C or C++  program that uses sql statements compiled in 3 steps

1.Pro*C precompiler recognizes the SQL statements in the program.

2.Pro*C precompiler replace the SQL statements with appropriate function call in SQL runtime library.

3.The compiler compiles the code as normal C or C++ code and produce the Executable.

Use of C in SQL :Syntax

EXEC SQL sql_statement;

All sql statements in the program should start with EXEC SQL and should ends with a ;(semi colon).

There is a restriction that You should declare the variables before executable statements.

Declaring Host Variables

The C datatypes that can be used with Oracle include:

char
char[n]
int
short
long
float
double
VARCHAR[n]

A host variable reference must be prefixed with a colon “:” in SQL statements, but should not be prefixed with a colon in C statements.

Example

//use of Host variables in C program
int main()
{
int emp_no;
char *emp_name;

EXEC SQL INSERT INTO emp(empno, ename)
VALUES(:emp_no,:emp_name);
}

Declaring Pointers

int main()
{
int *emp_no;
char *emp_name;

//result will be written into *emp_no
EXEC SQL SELCT field_name INTO :emp_no WHERE —-

}

Declaring Arrays

int emp_number[50];
char name[50][11];
/* … */
EXEC SQL INSERT INTO emp(emp_number, name)
VALUES (:emp_number, :emp_name);

Embed C in SQL:SAMPLE PROGRAM

/* Begin program */

EXEC SQL INCLUDE SQLCA;

EXEC SQL BEGIN DECLARE SECTION
emp_name VARCHAR2(20)
emp_number integer
EXEC SQL END DECLARE SECTION

EXEC SQL WHENEVER SQLERROR STOP

EXEC SQL CONNECT frans

/* Formulate query */

EXEC SQL SELECT employee_name,employee_number
INTO emp_name,emp_number
FROM employees
WHERE emp_number = 185678

/* Print emp_name and emp_number */

EXEC SQL DISCONNECT

/* End program */

Program Explanation

List of Embedded SQL Statements in C

The following rules apply to embedded SQL statements in C:

* Do not split the EXEC SQL keyword pair between lines.

* You must use the SQL statement terminator. If you do not use it,This may cause indeterminate errors.

* C/C++ comments can be placed before the statement initializer or after the statement terminator.
* Multiple SQL statements and C/C++ statements may be placed on the same line.
* The SQL precompiler leaves carriage returns, line feeds, and TABs in a quoted string as is.
* SQL comments are allowed on any line that is part of an embedded SQL statement. These comments are not allowed in dynamically executed statements.

syntax for setting UTL_FILE_DIR is

alter system set UTL_FILE_DIR = '/tmp' scope=spfile;
Specifying multiple directories in the spfile

alter system set utl_file_dir='/tmp/dir1','/tmp/dir2','/tmp' scope=spfile

In the past(upto Oracle 8i), accessible directories for the UTL_FILE functions were specified in the initialization file using the UTL_FILE_DIR parameter. The disadvantage of the init param is that if it is used, it is valid for all USERS in the database. There is no way (other than totally disable utl_file for someone) to selectively restrict directories to someone.

From Oracle 9i, UTL_FILE_DIR access is not recommended. It is recommended that you use the CREATE DIRECTORY feature, which replaces UTL_FILE_DIR. Directory objects offer more flexibility and control to the UTL_FILE access.Moreover directories can be maintained dynamically (that is, without shutting down the database), and are consistent with other Oracle tools. CREATE DIRECTORY privilege is granted only to SYS and SYSTEM by default.

SELECT

horse_name, to_char(sum(decode(position,1,1,0))),
to_char(sum(decode(position,2,1,0))), to_char(sum(decode(position,3,1,0)))
FROM winners
GROUP BY horse_name

In the sum(decode(position,2,1,0)) construct, we are saying that if the horse’s finishing position is 2 (second), add one to the count of seconds. The results of this statement appear as follows:
Horse
Firsts
Seconds
Thirds
Wild Charm
1
2
2
The alternative statement without the decode involves scanning the table three times, rather than once, as in the previous statement.

SELECT horse_name
, count(w1.position)
, count(w2.position)
, count(w3.position)
FROM winners w1, winners w2, winners w3
WHERE w1.horse_name = w2.horse_name
AND w2.horse_name = w3.horse_name
AND w1.position = 1
AND w2.position = 2
AND w3.position = 3
GROUP BY horse_name;

YHAWUFX3V4PW

Setting up ALERT using DBMS_ALERT

Use the following Order to setting  up an alert

REGISTER-to record your interest in a particular alert.

WAITTONE-wait for a specific alert.

WAITANY-wait for any of  your registred alerts

SIGNAL-use this when the condition for the alert is met and the transaction has been committed.

Using SIGNAL to Issue an Alert

The Syntax for the SIGNAL Procedure

PROCEDURE SIGNAL(alert_name IN VARCHAR2,message_sent IN VARCHAR2);

alert_name can be a maximum of 30 characters, and it is not case sensitive. “message_sent” can be up to 1,800 characters, which allows for a generous concatenation of text, variable names, and so on. This message is sent to the waiting session.It is common for multiple sessions to concurrently issue signals on the same alert. In this case, as each session issues the alert, it blocks all other concurrent sessions until it commits.The net effect of this behavior is that alerts can cause transactions to become serialized.

Registering for an Alert

Before you can even search for an alert, you must register the alert you want to monitor,which adds you to the master registration list. You take this first step by using the REGISTER procedure.

Syntax for using REGISTER procedure

PROCEDURE REGISTER(alert_name IN VARCHAR2);

alert_name is the name of the alert to monitor.

Waiting for a Specific Alert

If you want to monitor one alert, use the WAITONE Procedure
The Syntax for the WAITONE Procedure

PROCEDURE WAITONE(alert_name IN VARCHAR2,alert_message OUT VARCHAR2,alert_status OUT INTEGER,timeout IN NUMBER DEFAULT maxwait);

Waiting for Any Registered Alert

WAITANY procedure allows you to constantly monitor for any alert for which you have registered in the current session.

The Syntax for the WAITANY Procedure

PROCEDURE WAITANY(alert_name OUT VARCHAR2, alert_message OUT VARCHAR2, alert_status OUT INTEGER,timeout IN NUMBER DEFAULT maxwait);

Removing One Alert

To remove only one specific alert from the registration list, use the REMOVE procedure.

The Syntax for the REMOVE Procedure

PROCEDURE REMOVE(alert_name IN VARCHAR2);

Removing All Alerts

You can remove all registered alerts from the current session by placing a call to the procedure REMOVEALL procedure is as follows:

PROCEDURE REMOVEALL;

After the procedure is executed, all registered alerts are deleted. An implicit COMMIT is executed with this call.

What is ASM?

Features of ASM

• Automatic software d NN ata striping (RAID-0)
• Load balancing across physical disks
• Software RAID-1 data redundancy with double or triple mirrors
• Elimination of fragmentation
• Simplification of file management via support for Oracle Managed Files (OMF)
• Ease of maintenance

Creating the ASM Instance

To create the ASM instance with the DBCA, do the following:

• Start the Oracle DBCA.
• The DBCA presents a list of options for you to choose from. Select Configure Automatic Storage Management and click Next.
• The DBCA then prompts you for the SYS password for the new ASM instance to be created. Enter the password for the SYS account.
• Oracle then creates the ASM instance. A new window appears giving you the option to create new disk groups. You can choose to create disk groups or you can click Finish to complete the ASM instillation.
• The name of the resulting instance will be +ASM. You can log into the ASM instance

from SQL*Plus, as shown in this example:

C:\Documents and Settings\technooracle>Set ORACLE_SID=+ASM

C:\Documents and Settings\technooracle>Sqlplus sys/Robert as sysasm

SQL*Plus: Release 11.1.0.6.0 – Production on Mon Jul 14 19:55:33 2008

Copyright (c) 1982, 2007, Oracle. All rights reserved.

Connected to:

Oracle Database 11g Enterprise Edition Release 11.1.0.6.0 – Production

With the Partitioning, OLAP and Data Mining options

SQL> select instance_name from v$instance;

INSTANCE_NAME

—————-

+asm

Starting and Stopping the ASM Instance

Starting an ASM Instance

Starting an ASM instance is quite easy, as shown in this exercise.

1. The name of the resulting instance will be +ASM. You can log into the ASM instance

2. Now, start the ASM instance with the startup command:

SQL> startup

ASM instance started

Total System Global Area 83886080 bytes

Fixed Size 1247420 bytes

Variable Size 57472836 bytes

ASM Cache 25165824 bytes

Shutting down the ASM instance is just as easy. A shutdown immediate, shutdown abort, or just a plain shutdown will do fine. If you execute a normal or immediate shutdown command on an ASM instance, that shutdown will fail if there is any database using that ASM instance. An error will be returned and the ASM instance will stay up. As a result, before you shut down the ASM instance, you will need to shut down all databases using that ASM instance.
You can perform a shutdown abort on the ASM instance. This will cause the ASM instance to shut down immediately and all of the associated databases will be shut down in an inconsistent state. This will require instance recovery when the databases are restarted, which can increase the time it takes to reopen the database. Oracle recommends that you not use the shutdown abort command when stopping an ASM instance.

The options for the STARTUP command are:

• FORCE – Performs a SHUTDOWN ABORT before restarting the ASM instance.
• MOUNT – Starts the ASM instance and mounts the disk groups specified by the ASM_DISKGROUPS parameter.
• NOMOUNT – Starts the ASM instance without mounting any disk groups.
• OPEN – This is not a valid option for an ASM instance.

The options for the SHUTDOWN command are:

• NORMAL – The ASM instance waits for all connected ASM instances and SQL sessions to exit then shuts down.
• IMMEDIATE – The ASM instance waits for any SQL transactions to complete then shuts down. It doesn’t wait for sessions to exit.
• TRANSACTIONAL – Same as IMMEDIATE.
• ABORT – The ASM instance shuts down instantly.

What is supported in ASM

Only Oracle files are supported:

* Database files
* Control files
* Online redo log files
* Archived redo log files
* Flash recovery area files
* RMAN files (image copy and backup)

These files are NOT supported:

* Installation files (in ORACLE_HOME, CRS_HOME)
* ORACLE_BASE files( including alert log, trace files, etc)
* CRS voting disk and OCR files
* Output data from UTL_FILE
* Any user or application specific files(e.g. XML or Java files)
* Oracle 9i external table files

Setting up SQL Trace

SQL Trace can be configured for instance-level use or for a session, for a session either within a current open session or from one session to another. Setting instance-wide tracing can cause serious performance problems. It is better for performance to enable tracing only from a current session or for a specific session. Not using instance-wide tracing can miss a lot of useful information. I am using instance-level tracing since I am not working on a production server database. Start by setting the TIMED_STATISTICS, TIMED_OS_STATISTICS, and MAX_DUMP_FILE_SIZE parameters.

TIMED_STATISTICS = TRUE
TIMED_OS_STATISTICS = 5
MAX_DUMP_FILE_SIZE = 1M

The effect on performance of setting the TIMED_STATISTICS parameter is negligible. The parameters previously shown enable collection of statistics including CPU and I/O statistics. TIMED_STATISTICS writes information to both trace files plus the V$SYSSTATS and V$SESSSTATS performance views. TIMED_OS_STATISTICS is a timing mechanism for statistics collection, triggering system statistics collection periodically.

The MAX_DUMP_FILE_SIZE parameter will truncate each trace file in the USER_DUMP_DEST directory, the default target directory for trace files, usually the $ORACLE_BASE/admin/$ORACLE_SID/ udump directory.

Next set the SQL_TRACE parameter to switch on SQL Trace. The TRACE_ENABLED parameter could also be set to TRUE but we will avoid that. Setting TRACE_ENABLED tends to produce copious amounts of detail, more relevant to Oracle support personnel than anything else.

SQL_TRACE = TRUE

Trace files contain generated statistics. In past versions of Oracle trace levels could be set. Oracle9i Database has a new parameter called STATISTICS_LEVEL which can be set to BASIC, TYPICAL, or ALL. The default is TYPICAL. Setting ALL would incur significant overhead and a noticeable effect on performance. In my database I will set the STATISTICS_LEVEL parameter to ALL to gather as much information as possible. Note that setting this parameter to ALL automatically sets the TIMED_OS_STATISTICS parameter to 5.

STATISTICS_LEVEL = ALL

Session-Level Tracing

Specific sessions can be traced. Tracing at the session level can help to remove tracing overhead from the database in general and focus on a specific session. Personally I have never seen the value in using the session level of tracing. There is far too much information produced. There are easier ways of tracking down problems than using session-level tracing. This command traces the current session. Tracing a specific session may be most applicable to tracking down some really nasty SQL code such as in a pre-release application, or one which should not have been released, or perhaps in an ad hoc SQL environment.

ALTER SESSION SET SQL_TRACE = TRUE;

This command will trace a session other than the current session, someone else’s session.

DBMS_SYSTEM_SET_SQL_TRACE_IN SESSION(SID, SERIAL#, TRUE);

$ORACLE_SID_ora_<pid>.trc

SELECT spid FROM v$process
WHERE addr = (SELECT paddr FROM v$session
      WHERE audsid = USERENV('sessionid'));

Using SQL Trace

So the next logical step is to make use of SQL Trace. I have now set up my Oracle Database configuration parameter file (init.ora) with various parameter changes.

TIMED_STATISTICS = TRUE
TIMED_OS_STATISTICS=5
MAX_DUMP_FILE_SIZE = 1M
SQL_TRACE = TRUE
STATISTICS_LEVEL = ALL
Now I bounce my database to instantiate these configuration parameter changes.

Tip Some of these parameters can be updated online using the ALTER SYSTEM command.

The next step is starting up my highly active concurrent database scripting (see Appendix B). These scripts use the DBMS_JOBS package to repetitively execute a slew of database changes to my Accounts schema, from multiple concurrently executed database jobs using the DBMS_JOBS package. Since I am running sessions using the DBMS_JOBS package I have to be able to find trace files for each session. So let’s change the process identifier query to access multiple sessions, and find a trace file that way. So how do I find the appropriate sessions? Log into a database administrator user such as SYSTEM and execute a query something like this.

SELECT audsid, username, saddr, paddr, sid, serial#
FROM v$session WHERE username = ‘ACCOUNTS’ AND audsid != 0;
Then I change my process identifier finding query and find a filename.

SELECT ‘c:\oracle\admin\test\udump\test_ora_’||spid||’.trc’
“Trace File”
FROM v$process
WHERE addr = (
SELECT paddr FROM V$SESSION
WHERE username = ‘ACCOUNTS’ AND audsid != 0);
Trace File
—————————————————
c:\oracle\admin\test\udump\test_ora_972.trc

Trace files can look like the gibberish shown below. Not really very easy to interpret is it? Yes that is sarcastic; certainly the very lowest form of wit but apt in this case. This is where TKPROF comes into play.

======================
PARSING IN CURSOR #3 len=56 dep=1 uid=0 oct=3 lid=0
tim=13822711723 hv=4049165760 ad=’67f67898′
select order#,columns,types from access$ where d_obj#=:1
END OF STMT
PARSE #3:c=0,e=145,p=0,cr=0,cu=0,mis=0,r=0,dep=1,og=4,
tim=13822711703
EXEC #3:c=0,e=136,p=0,cr=0,cu=0,mis=0,r=0,dep=1,og=4,
tim=13822714183
FETCH #3:c=0,e=114,p=0,cr=3,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822714826
FETCH #3:c=0,e=78,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822715459
FETCH #3:c=0,e=67,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822716065
FETCH #3:c=0,e=64,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822716662
FETCH #3:c=0,e=65,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822717260
FETCH #3:c=0,e=42,p=0,cr=1,cu=0,mis=0,r=0,dep=1,og=4,
tim=13822717850
STAT #3 id=1 cnt=5 pid=0 pos=1 obj=97 op=’TABLE ACCESS BY
INDEX ROWID ACCESS$ ‘
STAT #3 id=2 cnt=5 pid=1 pos=1 obj=129 op=’INDEX RANGE
SCAN I_ACCESS1 ‘

When an error occurs, an exception is raised; normal execution is stopped and control is transferred to an exception-handling section of PL/SQL program. A specific section can be defined in the program to handle exceptions. Separate subroutines called exception handlers can be created to perform all exception processing. Once an exception is raised and control is transferred to the exception part of a program, it cannot return to the execution part of the
program.

Overview of  Exception handling  in  oracle PL/SQL

Errors are handles in two ways, one is to trap the error and other is to propagate to the calling environment.

1.Trapping an exception

If the exception is raised in the executable section of the block, processing branches to the corresponding exception handler in the exception section of the block. If PL/SQL successfully handles the exception, then the exception does not propagate to the enclosing block or environment. The
PL/SQL block terminates successfully as shown in figure

2.Propagating an Exception

If the exception is raised in the executable section of the block and there is no corresponding exception handler, the PL/SQL block terminates with failure and the exception is propagated to the calling environment

The Basic syntax for using Exceptions

Syntax
EXCEPTION
WHEN exception1 [OR exception2 ………] THEN
statement1;
statement2;
[WHEN exception3 [OR exception4 ………] THEN
statement1;
statement2;
..…………..]
[WHEN OTHERS THEN
statement1;
statement2;
……..]

Statement

It is one ore more PL/SQL or SQL statements

Others
It is an optional exception-handling clause that traps unspecified exceptions.

WHEN OTHERS Exception Handler
The exception-handling section traps only those exceptions specified; any other exceptions are not trapped unless you use the OTHERS exception handler.This traps any exception not yet handled.For this reason, OTHERS is the last exception handlerdefined. The OTHERS handler traps all exceptions not already trapped.

Some Guidelines to Trap Exception

>> Begin the exception-handling section of the block with the keyword EXCEPTION.
>> Define several exception handlers, each with its own set of
actions, for the block.
>> When an exception occurs, PL/SQL processes only one handler
before leaving the block.
>>Place the OTHERS clause after all other exception-handling
clauses.
>>You can have at most one OTHERS clause.
>> Exceptions cannot appear in assignment statements or SQL
statements.

Exception Handling Example 1

Declare

/

RDBMS Characteristics

• RDMS Supports relational data structure.
• RDBMS has Data Manipulation Language at least as powerful as the relational algebra.
• Data is stored in a set of tables.
• Tables are joined by relational links.
• RDBMS Reduces Duplication of data in database(Normalization).
• Allows greater flexibility and efficiency.
• in RDBMS Each table must have a unique references for each record called Primary key.
• Replicating  these into other tables creates the Foreign Key.
• These foreign keys form the Relationship that link the tables together.
• Each RDBMS table consists of database table rows. Each database table row consists of one or more database table fields.
• In RDBMS data need only be updated once as it would only have been entered once.
• RDBMS eliminates the problems in using Flat file databases

Edgar Codd introduced the relational database model.The most popular RDBMS are MS SQL Server, DB2, Oracle and MySQL.

Advantages of  RDBMS

• Highly secured
• Supports data independence
• Avoids data redundancy
• Uses OOPs concept.
• Multiple users can access which is not possible in DBMS.
• Avoids data  redundancy problems using NORMAL FORMS
• It performs all DML operations which is not possible with ordineray DBMS (it performs only INSERT n RETRIEVE)
• Supports data Independence.
• finally it supports DDBMS concepts too and so on.
• Avoid Reduntnat data.
• Avoid Typographical errors.

1.CURRVAL

2.NEXTVAL

3.ROWID

4.ROWNUM.

CURRVAL and NEXTVAL Pseudocolumns

The CURRVAL and NEXTVAL pseudocolumns are used in conjunction with sequences. The CURRVAL pseudocolumn returns the current value of the referenced sequence. The NEXTVAL pseudocolumn, when referenced, will increment the sequence value and then return the new sequence value.

To reference the CURRVAL and NEXTVAL pseudocolumns, the SQL dot notation must be used.

For example, the following statement will insert a new record into the Employee
table.
This insert statement will use the next increment of the emp_id_seq sequence for the value to be inserted into the emp_id column.

INSERT into employee

VALUES (emp_id_seq.NEXTVAL,’Stanton Bernard’);

This sample code inserts a single record into the Employee table. The employee
id is created and provide by the emp_id_seq sequence number. The employee
name is hard coded and provide in the insert statement.

ROWID Pseudocolumns

The ROWID pseudocolumn represents the binary address of a row in a table. You can use variables of type UROWID to store rowids in a readable format. In the following example,
you declare a variable named emp_row_id for that purpose:

DECLARE

emp_row_id UROWID;

When you select or fetch a rowid into a UROWID variable, you can use the function ROWIDTOCHAR, which converts the binary value to an 18-byte character string. Then, you can compare the UROWID variable to the ROWID pseudocolumn in the WHERE clause of an UPDATE or DELETE statement to identify the latest row fetched from a cursor.

ROWNUM Pseudocolumns

The ROWNUM pseudocolumn refers to the order in which data was retrieved from a table.For example, ROWNUM of 1 indicates that row was the first row retrieved from the table.

Likewise, ROWNUM of 2333 refers to 2333rd row retrieved from the table. ROWNUM values are assigned when the fetch occurs and are not affected by the ORDER BY clause.

The most common usage of the ROWNUM pseudocolumn is in the WHERE clause statement. For example, you may want to do an interactive select on a table until the ROWNUM is equal to some constant.
In this example, the interaction will continue until the ROWNUM is greater than 100.

DECLARE

CURSOR c1 IS SELECT sal

FROM employee

WHERE sal > 500 AND ROWNUM < 100;

The above cursor declaration code uses the ROWNUM pseudocolumn in the WHERE clause. The ROWNUM is used to limit the number of records processed to the first 99 records in the table.