This is useful when you find that a runaway ghost process is hogging CPU or memory and you can see what the OS level sid is, but you have no idea which job it is related to:

For example, running top showed you that process 25042 is a problem and ps -ef | grep 25042 shows you that it is Oracle process  ora_j001_<sid>.

Well, run the following query and you will see which job is the culprit:

set linesize 250
col sid for 9999 head ‘Session|ID’
col spid head ‘O/S|Process|ID’
col serial# for 9999999 head ‘Session|Serial#’
col log_user for a10
col job for 9999999 head ‘Job’
col broken for a1 head ‘B’
col failures for 99 head “fail”
col last_date for a18 head ‘Last|Date’
col this_date for a18 head ‘This|Date’
col next_date for a18 head ‘Next|Date’
col interval for 9999.000 head ‘Run|Interval’
col what for a60
select j.sid,
s.spid,
s.serial#,
j.log_user,
j.job,
j.broken,
j.failures,
j.last_date||’:'||j.last_sec last_date,
j.this_date||’:'||j.this_sec this_date,
j.next_date||’:'||j.next_sec next_date,
j.next_date – j.last_date interval,
j.what
from (select djr.SID,
dj.LOG_USER, dj.JOB, dj.BROKEN, dj.FAILURES,
dj.LAST_DATE, dj.LAST_SEC, dj.THIS_DATE, dj.THIS_SEC,
dj.NEXT_DATE, dj.NEXT_SEC, dj.INTERVAL, dj.WHAT
from dba_jobs dj, dba_jobs_running djr
where dj.job = djr.job ) j,
(select p.spid, s.sid, s.serial#
from v$process p, v$session s
where p.addr = s.paddr ) s
where j.sid = s.sid;

The rest of the post discusses how to kill the ghost process as well as the job, read it here

There are 5 kinds of constraints :

• Check
• Not-Null
• Unique
• Primary Key
• Foreign Key

Check Constraints

A check constraint allows you to define a function which determines whether the data is allowable or not.

Example: Let’s add a check constraint to employees.surname (table Employees, column Surname)
which will only allow characters to be entered in upper case:

If you try to add a surname in lower case , you will receive the following error:

Now let’s add it the proper way:

Not-Null Constraints

This simple constraint determines whether your column is allowed to contain null data.
By default, a column can contain null data, unless you add a not-null constraint.

Example : Let’s add a not-null constraint to Employees.Surname

Now try to insert a null value.

Unique Constraints

These constraints enforce uniqueness in your column’s data : it will stop duplicated data from being inserted.

Example:

We know there is already an entry named ‘JONES’ in the table, so let’s see what happens when we try to insert it again:

Primary Key Constraints

A primary key constraint is a combination of a unique and a not-null constraint.
It allows you to use a column in your table to uniquely identify each row by your predetermined key.
Creating a primary key automatically creates a unique index of the same name on the table.
This is how Oracle enforces the uniqueness.

Example: Before we can create a primary key, let’s drop the previous not-null and unique key constraints.

Either inserting a pre-existing surname or attempting to insert a null value into the surname column
will now result in an error.

Foreign Key Constraints

Another name for these is relational integrity constraints.
They enforce logical relationships between parent and child tables.

Let’s use a geographical example.

We have a parent table called Countries and a child table called Cities.
A row in the Cities table must be able to find its parent Country in the Countries table
before you are allowed to insert the City.

Parent table Countries :

Child table Cities:

To implement this is slightly more complicated than the other constraints:
First you create the primary key on the parent table:

Now we create the foreign key constraint on the child table which references the primary key on the parent table:

Time to test: let’s try to add a row in Cities with a non-existent Countryid.

Recommended reading:

Below is a list of some commonly used sql functions, with an example of each:

• add_months
• avg
• ceil
• chr
• concat
• count
• decode
• dump
• floor
• greatest
• initcap
• instr
• last_day
• least
• length
• lower
• lpad
• ltrim
• max
• min
• mod
• months_between
• next_day
• nullif
• nvl
• nvl2
• replace
• round
• rpad
• rtrim
• sqrt
• substr
• sum
• sysdate
• to_char
• to_date
• to_number
• translate
• trim
• trunc
• upper

add_months

Returns the supplied date with the requested number of months added to it.
If the supplied date has a day value which is larger than the maximum number of days
in the resulting month, the result is the last day of that month.

avg

Returns the average of a series of numbers.

ceil

Returns the smallest integer larger than the supplied argument.
Opposite of sql function: floor.

chr

Returns the character equivalent of the supplied integer.

concat

Returns the first argument concatenated with the second argument.
The result’s dataype will depend on the datatype of the arguments.
I prefer to use the two pipe symbols (||) to concatenate.

count

Returns the number of rows as requested by the query, either all rows or only distinct values.
By specifying *, it will return all rows including duplicates and nulls.
If no rows match your query, count will return 0. (never null)

decode

The oracle decode function takes up to 255 argument sets and returns the relevant result depending on the value found.
This is similar to the ‘case’ statement in other languages.
The last argument is what will be returned if no match is found in the decode statement.

dump

Returns a string representing the argument’s datatype code, byte length and internal representation.
Very handy command if you are hunting for unexpected or hidden characters in your data.

floor

Returns an integer equal to or 1 less than the argument.
Opposite of oracle function : ceil.

greatest

Returns greatest ranking argument out of a list of arguments.
The ranking is determined by the value of the numerical codes of the whole character string.
Opposite of oracle function : least.

initcap

Returns the string with each word’s first letter capitalized.
Similar to oracle functions : lower and upper

instr

Returns the first position of a string inside another string.
The 1st argument is the string to be searched.
The 2nd argument specifies the character or string to search for.
The 3rd argument allows you to specify from which character position to start searching.
The 4th argument allows you to specify which occurence of the search string to return.

last_day

Returns the last day’s date of the supplied date’s month.

least

Returns the least or smallest ranking argument out of a list of arguments.
The ranking is determined by the value of the numerical codes of the whole character string.
Opposite of oracle function : greatest

length

Returns the length (as an integer) of the supplied argument.

lower

Returns the argument in lower case.
Similar to oracle functions : upper and initcap

lpad

Returns the first argument, left-padded by the third argument, so that the complete string is as long as specified by the second argument.
If you do not supply the third argument, blank spaces are used for padding.
Similar to oracle function : rpad

ltrim

Removes the second argument from the first argument.
If you do not supply the second argument, it will remove blank spaces.
Similar to oracle function: rtrim

max

Returns the largest of a series of numbers.
Similar to oracle function : min

min

Returns the smallest in a series of numbers.
Similar to oracle function : max

mod

Returns the remainder of the first argument divided by the second argument.
The result is floor-ed.

months_between

This date-oriented oracle function returns the number of months between two dates as a fraction.

next_day

Returns date of the day of the week (supplied as the second argument) after the date of the first argument.
The second argument is specified as the name of a weekday.

nullif

Returns null if the first and second argument are equal, if they are unequal, it will return the first argument.

nvl

Returns the second argument if the first argument is null.
Otherwise, the first argument is returned.
Similar to oracle function : nvl2

nvl2

This function is an extension to nvl by allowing you to specify a value to return if the argument to be checked is null.
So, nvl2 will return the third argument if the first argument is null and will return the second argument if the first argument is not null.
Similar to oracle function : nvl

replace

Returns the first argument with every occurence of the second argument replaced with the third argument.
If the third argument is left out, the second argument is removed from the first argument.
If the second argument is null, then the first argument is returned unmodified.

round (number)

Returns the first argument rounded to the number of places after the decimal point as specified by the second argument.
If the second argument is not specified, then the first argument is rounded to 0 places after the decimal point.
If the result is n.5, round will round up to the next integer, if the result is -n.5, it will round down to the next integer.

round (date)

This will always return a date.
The format of the second argument determines the timeperiod it will round to, like YEAR, MONTH, DAY, HH and MI.
If you do not specify a second argument, the format defaults to day.

rpad

Returns the first argument, right-padded by the third argument, so that the complete string is as long as specified by the second argument.
If you do not supply the third argument, blank spaces are used for padding.
Similar to oracle function : lpad

rtrim

Removes the second argument from the first argument.
If you do not supply the second argument, it will remove blank spaces.
Similar to oracle function : ltrim

sqrt

Returns the square root of the argument.

substr

This very useful sql function returns the part of the first argument, determined by what you specify as the second and third arguments.
The second argument tells Oracle from which character position to start counting.
It can contain a positive or negative value.
The third argument determines the number of characters to select.
If you do not supply this argument, all characters until the end are selected.

Read up more about this very useful oracle function :
Oracle online documentation : SQL Reference, substr

sum

Returns the sum of a range of numbers.

sysdate

Returns the current date and time of the local database server’s operating system.
You will see the date format as it is specified by the NLS_DATE_FORMAT
database initialization parameter.
You can set NLS_DATE_FORMAT for your session to overwrite the database’s default value.
Alternatively, you can convert sysdate to a character datatype using the to_char function.

to_char

Converts the argument to a character datatype, using the format specified by the second argument.
You can convert number, date and CLOB datatypes.

Read up more about format models here:
Oracle online documentation : SQL Reference, format models

to_date

Converts a character string to a date datatype.
If the character string is already in the default format, you do not need to specify a format as the second argument.
The default format is specified by initialization parameter NLS_TERRITORY or can be set by NLS_DATE_FORMAT.

Read up more about format models here:
Oracle online documentation : SQL Reference, oracle function format models

to_number

Converts a character datatype to a number datatype
The second argument supplies the format needed to do the conversion.

Read up more about format models here:
Oracle online documentation : SQL Reference, format models

translate

Returns a string which replaces all occurences of the characters in the second argument
with the characters of the third argument.
If the second argument contains more characters than the third argument,
the extra characters are removed from the result.

trim

Returns the third argument with the leading, ending or both sides of the argument’s characters trimmed.
The first argument specifies which side to trim from.
Values can be ‘LEADING’,'TRAILING’ or ‘BOTH’.
If null, both sides are trimmed.
The second argument specifies which character to trim. If null, blanks are assumed.
The third argument takes the form : FROM < source > which can be a column name.

trunc(number)

Returns the first argument truncated to the number of decimal places determined by the second argument.
If the second argument is not specified, Oracle assumes 0.

trunc(date)

Returns the date truncated to the day specified by the second argument’s format.
The format of the second argument determines the timeperiod it will truncate to, like YEAR, MONTH, DAY, HH and MI.
If you do not specify a second argument, the format defaults to DAY.

upper

Returns the argument with all characters in upper case.
Similar to oracle functions : lower and initcap

Recommended reading for more information on oracle functions :

Oracle online documentation: SQL Reference

• Definition
• Simple subquery
• Correlated subquery
• Update with correlated subquery
• Delete with correlated subquery

Definition

A subquery is basically a select clause which is used instead of another statement.

For example : Have a look at the following 2 tables : DEPT and EMP

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON

SQL> select empno,ename,job,sal,deptno from emp;

     EMPNO ENAME      JOB              SAL     DEPTNO
---------- ---------- --------- ---------- ----------
      7369 SMITH      CLERK            800         20
      7499 ALLEN      SALESMAN        1600         30
      7521 WARD       SALESMAN        1250         30
      7566 JONES      MANAGER         2975         20
      7654 MARTIN     SALESMAN        1250         30
      7698 BLAKE      MANAGER         2850         30
      7782 CLARK      MANAGER         2450         10
      7788 SCOTT      ANALYST         3000         20
      7839 KING       PRESIDENT       5000         10
      7844 TURNER     SALESMAN        1500         30
      7876 ADAMS      CLERK           1100         20
      7900 JAMES      CLERK            950         30
      7902 FORD       ANALYST         3000         20
      7934 MILLER     CLERK           1300         10

14 rows selected.

Simple Oracle subquery

A simple subquery is evaluated once for each table.

You would like to select all employees whose department is located in Chicago.

A join would be a better solution for this select,
but for the purposes of illustration we will use a subquery.

SQL> select empno,ename,job,sal,deptno from emp where
     deptno in (select deptno from dept
	 where loc = 'CHICAGO');

     EMPNO ENAME      JOB              SAL     DEPTNO
---------- ---------- --------- ---------- ----------
      7900 JAMES      CLERK            950         30
      7844 TURNER     SALESMAN        1500         30
      7698 BLAKE      MANAGER         2850         30
      7654 MARTIN     SALESMAN        1250         30
      7521 WARD       SALESMAN        1250         30
      7499 ALLEN      SALESMAN        1600         30

6 rows selected.

You can use a subquery in the place of a table name in the ‘from’ clause.

SQL> Select ename, deptno from
     (select ename, deptno from emp
	 where job = 'CLERK' )
     where
     deptno > 20;

ENAME          DEPTNO
---------- ----------
JAMES              30

You can even replace a column name with a subquery:

SQL> select ename,
            (select max(sal) from emp) "maxsal" ,
            sal,
            ((select max(sal) from emp ) - sal )
			"difference"  from emp;

ENAME          maxsal        SAL difference
---------- ---------- ---------- ----------
SMITH            5000        800       4200
ALLEN            5000       1600       3400
WARD             5000       1250       3750
JONES            5000       2975       2025
MARTIN           5000       1250       3750
BLAKE            5000       2850       2150
CLARK            5000       2450       2550
SCOTT            5000       3000       2000
KING             5000       5000          0
TURNER           5000       1500       3500
ADAMS            5000       1100       3900
JAMES            5000        950       4050
FORD             5000       3000       2000
MILLER           5000       1300       3700

14 rows selected.

Correlated Oracle subquery

A correlated Oracle subquery is evaluated once FOR EACH ROW as opposed to a normal subquery which is evaluated only once for each table.

You can reference the outer query inside the correlated subquery using an alias which makes it so handy to use.

Let’s select all employees whose salary is less than the average of all the employees’ salaries in the same department.

SQL> select ename ,sal ,deptno from emp a where
     a.sal < (select avg(sal) from emp b
	           where a.deptno = b.deptno)
     order by deptno;

ENAME             SAL     DEPTNO
---------- ---------- ----------
CLARK            2450         10
MILLER           1300         10
SMITH             800         20
ADAMS            1100         20
WARD             1250         30
MARTIN           1250         30
TURNER           1500         30
JAMES             950         30

8 rows selected.

Using a correlated subquery in an update

Let’s give these people (whose salary is less than their department’s average) a raise.

SQL> select ename, sal, deptno  from emp
     order by deptno, ename;

ENAME             SAL     DEPTNO
---------- ---------- ----------
CLARK            2450         10
KING             5000         10
MILLER           1300         10
ADAMS            1100         20
FORD             3000         20
JONES            2975         20
SCOTT            3000         20
SMITH             800         20
ALLEN            1600         30
BLAKE            2850         30
JAMES             950         30
MARTIN           1250         30
TURNER           1500         30
WARD             1250         30

14 rows selected.

SQL>  UPDATE emp a
      set sal = (select avg(sal)
                from emp b
	        where
	        a.deptno = b.deptno)
      where sal <
	   (select avg(sal) from emp c
	   where a.deptno = c.deptno);

8 rows updated.

SQL> select ename, sal, deptno  from emp
     order by deptno, ename;

ENAME             SAL     DEPTNO
---------- ---------- ----------
CLARK         2916.67         10
KING             5000         10
MILLER        2916.67         10
ADAMS            2175         20
FORD             3000         20
JONES            2975         20
SCOTT            3000         20
SMITH            2175         20
ALLEN            1600         30
BLAKE            2850         30
JAMES         1566.67         30
MARTIN        1566.67         30
TURNER        1566.67         30
WARD          1566.67         30

14 rows selected.

SQL> commit;

Commit complete.

Using a correlated subquery in a delete

Let’s delete the highest earning employees in each department.

SQL>  delete from emp a where
      a.sal = (select max(sal) from emp b
	  where a.deptno = b.deptno);

4 rows deleted.

SQL> select ename, sal, deptno  from emp
     order by deptno, ename;

ENAME             SAL     DEPTNO
---------- ---------- ----------
CLARK         2916.67         10
MILLER        2916.67         10
ADAMS            2175         20
JONES            2975         20
SMITH            2175         20
ALLEN            1600         30
JAMES         1566.67         30
MARTIN        1566.67         30
TURNER        1566.67         30
WARD          1566.67         30

10 rows selected.

SQL> commit;

Commit complete.

Lastly: do not forget to commit to make your changes permanent when using the oracle subquery statement.

Recommended reading:

The Oracle Delete statement allows you to remove rows from a table.

The syntax is : delete from
(where );

If you specify the delete statement without the where clause, you will delete all rows from a table.

Specifying the where clause will restrict the deletion to the rows which match the restriction clause.

Here is the sample table:

SQL> select * from dept order by deptno;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON
50 MARKETING MELBOURNE
60 IT HARTORD
70 CALLCENTRE
80 SUPPORT NONE
90 BOISE
91 SHIPPING DETROIT
92 FINANCE DETROIT

11 rows selected.

Let’s delete all rows that are located in Detroit.

SQL> delete from dept where loc = ‘DETROIT’;

2 rows deleted.

SQL> select * from dept order by deptno;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON
50 MARKETING MELBOURNE
60 IT HARTORD
70 CALLCENTRE
80 SUPPORT NONE
90 BOISE

9 rows selected.

Now let’s select all rows that have a null value in either the dname column or the deptno column.

SQL> delete from dept where dname is null or loc is null;

2 rows deleted.

SQL> select * from dept order by deptno;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON
50 MARKETING MELBOURNE
60 IT HARTORD
80 SUPPORT NONE

7 rows selected.

Now let’s delete all the remaining rows from this table:

SQL> delete from dept;

7 rows deleted.

SQL> select * from dept order by deptno;

no rows selected

Lastly: do not forget to commit to make your changes permanent after you use the Delete statement.

Recommended reading:

Oracle Online Documentation: SQL Reference, Delete statement

Syntax

update
set
= where ;

If you do not specify a where clause, all rows in the table will be updated.

Permissions
You must have update privileges to update another schema’s table.

If you want to update through a view, the view’s owner needs to have
update permissions on the base table and you need update privileges on the view.

The ‘update any table’ privilege sidesteps the 2 requirements above by combining them in one privilege.

Examples

Let’s use table SCOTT.DEPT as our example table.

DEPTNO DNAME LOC
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON

DEPT contains 3 columns (deptno, dname and loc) and 4 rows.

SQL> select * from dept;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON

I want to update the location for department ‘SALES’ to ‘LONDON’.

SQL> update dept set loc = ‘LONDON’
where dname = ‘SALES’;

1 row updated.

SQL> commit;

Commit complete.

SQL> select * from dept;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
30 SALES LONDON
40 OPERATIONS BOSTON

Let’s update 2 columns at the same time:

SQL> update dept set loc = ‘MIAMI’, deptno = 50
where dname = ‘SALES’;

1 row updated.

SQL> select * from dept;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING NEW YORK
20 RESEARCH DALLAS
50 SALES MIAMI
40 OPERATIONS BOSTON

SQL> commit;

Commit complete.

Let’s use a function to change the value of the location column:

SQL> update dept set loc = lower(loc) ;

4 rows updated.

SQL> commit;

Commit complete.

SQL> select * from dept;

DEPTNO DNAME LOC
———- ————– ————-
10 ACCOUNTING new york
20 RESEARCH dallas
50 SALES miami
40 OPERATIONS boston

Lastly: do not forget to commit to make your changes permanent.

Recommended reading:

# Oracle Online Documentation: SQL Reference, Update statement

The Oracle Insert statement allows you to add data to a table.

Contents :

• Inserting without specifying column names
• Inserting by specifying column names
• Insert a column’s default value
• Inserting a null value
• Inserting multiple rows by means of a subquery

The syntax is : insert into <table_name> ( <column list>) values (<values list>);

You do not have to specify the column names if your value list is in the same order as the columns of the table, but it is best to always specify the column names.

Sample table for use in the Oracle Insert syntax tutorial:

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON

No column list

When you do not specify the column list, you can use the values clause immediately after
the table clause, but Oracle will expect the values to match the column datatypes,
so you must make sure that the values are in the same order as the table’s columns.

To see what the order of a table’s columns is,
use the ‘DESCRIBE’ statement or its abbreviation ‘desc’ :

SQL> describe dept
 Name                   Null?    Type
 ---------------------- -------- ---------------

 DEPTNO                          NUMBER(2)
 DNAME                           VARCHAR2(14)
 LOC                             VARCHAR2(13)

SQL> insert into dept values
     (50,'MARKETING','MELBOURNE');

1 row created.

SQL> commit;

Commit complete.

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON
        50 MARKETING      MELBOURNE

Using a column list

SQL> insert into dept (deptno,dname,loc)
     values (60,'IT','HARTFORD');

1 row created.

SQL> commit;

Commit complete.

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON
        50 MARKETING      MELBOURNE
        60 IT             HARTFORD

6 rows selected.

Using a column list allows you to insert values for selected columns only:

SQL> insert into dept (deptno,dname)
     values (70,'CALLCENTER');

1 row created.

SQL> commit;

Commit complete.

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON
        50 MARKETING      MELBOURNE
        60 IT             HARTORD
        70 CALLCENTER

7 rows selected.

Default values
You can choose to insert a column’s default value like this:
Let’s first change the DEPT table to have a default value of ‘NONE’ for the location column:

SQL> alter table dept modify (loc default 'NONE');

Table altered.

SQL> insert into dept (deptno,dname,loc)
     values (80,'SUPPORT',DEFAULT);

1 row created.

SQL> commit;

Commit complete.

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON
        50 MARKETING      MELBOURNE
        60 IT             HARTORD
        70 CALLCENTER
        80 SUPPORT        NONE

8 rows selected.

Inserting a null value

Use the ‘null’ identifier to insert a null value instead of a real value.

SQL> insert into dept (deptno,dname,loc)
     values (90,NULL,'BOISE');

1 row created.

SQL> commit;

Commit complete.

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON
        50 MARKETING      MELBOURNE
        60 IT             HARTORD
        70 CALLCENTER
        80 SUPPORT        NONE
        90                BOISE

9 rows selected.

Inserting multiple rows by means of a subquery

Instead of adding one row at a time, here is an example of inserting a number of rows by using a subquery:

We have another table called DEPT_MERGE with the same table structure as DEPT and with rows which need to be added to DEPT.

SQL> select * from dept_merge order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        91 SHIPPING       DETROIT
        92 FINANCE        DETROIT

SQL> insert into dept
  2  (select * from dept_merge);

2 rows created.

SQL> commit;

Commit complete.

SQL> select * from dept order by deptno;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON
        50 MARKETING      MELBOURNE
        60 IT             HARTORD
        70 CALLCENTER
        80 SUPPORT        NONE
        90                BOISE
        91 SHIPPING       DETROIT
        92 FINANCE        DETROIT

11 rows selected.

Lastly: do not forget to commit to make your changes permanent after you use the Oracle Insert statement.

Recommended reading:

How to query the Oracle database

Always test these ‘select’ commands on a test server
before implementing them on a production server.

This tutorial will show you how to use the correct syntax to query data in the Oracle database.

When you query an object, you could be querying a table, a synonym or a view,
but this will make no difference to the syntax you need to use or to the result you will obtain.

A table consists of a number of columns and rows and your query will be built so that you decide which rows and which columns to return.

The simplified syntax for the queries we’ll be using in this tutorial is as follows:

select <column list> from <table> where <row criteria> ;

For example: (log in as scott/tiger)

Table DEPT looks like this :

There are 3 columns : DEPTNO, DNAME and LOC
There are 4 rows.

Column criteria

Let’s query all columns and all rows:

SQL> select deptno, dname, loc from dept;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH       DALLAS
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON

Time saving tip: use * instead of the whole column list if you plan to return each column
in the table:

Let’s only query the Location column in the table.

SQL> select loc from dept;

LOC
-------------
NEW YORK
DALLAS
CHICAGO
BOSTON

Now let’s query both the DNAME and LOC columns from this table:

SQL> select dname, loc from dept;

DNAME          LOC
-------------- -------------
ACCOUNTING     NEW YORK
RESEARCH       DALLAS
SALES          CHICAGO
OPERATIONS     BOSTON

Row criteria

To specify only a subset of rows to be returned,
you will use the WHERE clause.

Let’s query only the rows in the dept table belonging to the SALES department.
We will query all columns.

SQL> select * from dept where dname = 'SALES';

    DEPTNO DNAME          LOC
---------- -------------- -------------
        30 SALES          CHICAGO

We could also decide to make the DEPTNO the criteria to deliver the same result.

SQL> select * from dept where deptno = 30;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        30 SALES          CHICAGO

What if we want to query all rows related to departments that have department numbers larger than 20 ?

SQL> select * from dept where deptno > 20;

    DEPTNO DNAME          LOC
---------- -------------- -------------
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON

What if you want to make your where clause more complex ?

Let’s look for any rows that have ‘SALES’ as a department name but also any rows that have ‘BOSTON’ as the location.

This means that
any row contains the value ‘SALES’ in the DNAME column,
as well as
any row containing the value ‘BOSTON’ in the LOC column
will be included in the result set.

You can do so by adding another section to the where clause and using the ‘OR’ term to glue them together.

SQL> select * from dept
     where dname = 'SALES' or loc = 'BOSTON';

    DEPTNO DNAME          LOC
---------- -------------- -------------
        30 SALES          CHICAGO
        40 OPERATIONS     BOSTON

If you want your result set to return only rows
where the location is ‘BOSTON’
and
the department name is ‘SALES’,
you will see 0 rows returned because no row has both those values for the relevant columns :

SQL> select * from dept
     where dname = 'SALES' and loc = 'BOSTON';

no rows

Note on datatypes
Your where clause will have to be aware of which type of data you are using as query criteria.
In other words, you must be sure to use the correct datatype in your where clause.

For example, DNAME is a varchar column, so you must put single quotes around your query criteria.
(Only number datatypes do not need single quotes)

If you try to specify SALES in your where clause like this :

where dname = SALES;

you will receive an error:

ORA-00904: “SALES”: invalid identifier

because you are expected to supply single quotes around a varchar datatype like this:

where dname = ‘SALES’;

How do you know the datatype of a column in a table ?

Use DESCRIBE to see which columns are in a table and what their datatypes are:

SQL> desc dept;
 Name                Null?    Type
 ------------------- -------- -----------------

 DEPTNO                       NUMBER(2)
 DNAME                        VARCHAR2(14)
 LOC                          VARCHAR2(13)

Varchar tip
Oracle is case sensitive to data inside the tables,
unlike column and table names which are usually upper case unless you explicitly create them otherwise.

So, there is a difference between ‘SALES’, ‘sales’ and even ‘Sales’.

If you are unsure of the case that is used in your data, you can force the result to upper (or lower)
case by calling the upper or lower function to convert the column data, like this:

… where lower(dname) = ‘sales’;.

Recommended reading:

Spend some time reading Oracle’s documentation to get comfortable with Oracle’s syntax.

It will be worth the effort.

It is the language you will use to access any data structure or its data in the Oracle database.

You will use this to issue commands to send instructions to the database.

It is a standard across all compliant databases.

SQL commands work on sets of data and allow you to :

• Query the data (select)
• Change the data (insert, update, delete)
• Work with data structures (create or replace, alter, drop)
• Determine access rules to data and structures (grant)
• Lock rows or tables to enforce consistency. (lock)

Tables and indexes

A table is a structure which contains horizontal rows and vertical columns.

The intersection of a row and a column is a cell.

When we search for data in a table, we use the SQL ‘select’ statement to extract the data in the table cells by specifying which ‘intersection’ of column and row we want to extract results for. (More details later..)

Here’s a real-world example of a table:

Table: Employees, contains 3 columns : EmployeeID, Surname and Firstname and 4 rows of data.
Each table has a hidden column called rowid which uniquely identifies each row in the table.

Index: a technique implemented by the database engine to conduct data access as fast as possible.

An index on the ‘Surname’ column of the Employees table would create another ‘table’ (but now called an index) containing only the sorted Surname data and the rowid of that row.

When you query data in the Surname column of the Employees table,
the database engine’s optimizer determines whether or not to use the index,
based on the expected number of rows it has to return.
If it detects and uses the relevant index, it does a search on the index rather than the table.

Once if finds the correct row, it uses the stored rowid to access the Employees table directly (no searching) to retrieve the whole row.

Once an index is created, you do not need to maintain it, nor do you need to use its name to access
the data in the table. The Oracle engine does that for you in the background.

Normalization:

A methodology to design a database system in such a way so that there is no or limited data duplication.
No table should contain data already stored in another table unless it is a link to a row
in the other table (foreign key relationships).
There are many other rules and degrees of normalization , if you would
like to read more about it , see the link below in ‘Additional resources’.

Recommended reading:

For more info on relational database theory, here’s an excellent well-priced resource: