what is the difference between primary key and foreign key?

A primary key is a column which uniquely identifies the records in a table. In a broad sense, a primary key is the
mixture of a unique key and an index: A column with a primary key is indexed to deliver a faster query, and doesn't allow
duplicate values to ensure specific data.
A foreign key is a column (the child column) in a table which has a corresponding relationship and a dependency
on another column (the parent column) that is usually in a different table. Parent columns can have multiple child columns,
but a child column can only have one parent column.
Primary key does't allow null value while foreign key allow null value

Foreign Key
1. A foreign key can refer
to its own relation.
2. One or more Foreign
key can be treated in Parent table.
3. Foreign key constraints
can be defined at the column or
table constraint level.

Primary Key
1. The Primary key clause speci-files one or more attributes that make up
primary key of a relation.
2. One Primary key can be
treated for each table.
3. Primary key constraint is a
column or set of columns that uniquely
identifies each row in a table.

Difference between primary and unique key constraints

Unique Key Constraints
The column values should retain uniqueness.
It allows null values in the column.
It will create non-clustered index by default.
Any number of unique constraints can be added to a table.
Primary Key Constraints
Primary key will create column data uniqueness in the table.
It will not allow Null values.
By default Primary key will create clustered index.
Only one Primary key can be created for a table.
Primary Key - This is an index that cannot be NULL, Primary Keys are used in building relationships between tables in a
database. (an index is automatically created on the primary key). The difference between primary and ordinary keys is that
there can be multiple keys, but only one primary key.
Unique Key - Unique and Index are same, the difference is, in Unique, duplicate are not allowed in any circumstances and
that is enforced by database server. Primary key(s) qualify to be Unique on basis of their uniqueness.In case, your table has
2 primary keys means that the 2 fields together form one unique key. Each field by itself may have repeating values, but
both primary keys combined together must be unique.
A primary key is an unique identifier for a table object. Typically, primary keys are numeric but can be strings (such as
guids or other unique character sets). The important thing is that primary keys are unique - each row entry includes a
distinctly different primary key entry that cannot (or should not) reoccur as a primary key for another entry. An example
would be the unique customer id you would find on any invoice that clearly points to the details of 1 and only 1 customer.
A secondary key is most often found when the use of a single field will not represent unique sequencing. For instance, if
one field, say last name is not enough to create the unique nature needed for a primary key, a second field will be included
to make the combination unique.
A foreign key is what allows multiple tables to efficiently interact. Once a primary key is created on one table, a second

table can access the information in the first table by including a column to hold just the primary key value as a foreign key.
When pulling information processes can take information from an orders table and use the foreign key on the order to
reference all of the information for the customer that foreign key relates.
Primary Key: A column in a table whose values uniquely identify the rows in the table. A primary key value cannot be
NULL.
Unique Key: Unique Keys are used to uniquely identify each row in an Oracle table. There can be one and only one row
for each unique key value.
Surrogate Key: A system generated key with no business value. Usually implemented with database generated sequences.
The Difference Between UNION and UNION ALL
UNION performs a DISTINCT on the result set, eliminating any duplicate rows.
UNION ALL does not remove duplicates, and is therefore faster than UNION.
The basic difference between UNION and UNION ALL is union operation eliminates the duplicated rows from the result
set but union all returns all rows after joining.
union is used to select distinct values from two tables where as union all is used to select all values including duplicates
from the tables
UNION
The UNION command is used to select related information from two tables, much like the JOIN command. However,
when using the UNION command all selected columns need to be of the same data type. With UNION, only distinct
values are selected.
UNION ALL
The UNION ALL command is equal to the UNION command, except that UNION ALL selects all values.
The difference between Union and Union all is that Union all will not eliminate duplicate rows, instead it just pulls all rows
from all tables fitting your query specifics and combines them into a table.
A UNION statement effectively does a SELECT DISTINCT on the results set. If you know that all the records returned
are unique from your union, use UNION ALL instead, it gives faster results.
Example :Table X contain values(a,b,c) and Table Y contain values(c,d,e)
In Case Of Union we will get Result-a,b,c,d,e
and other hand (Union All ) we will get-a,b,c,c,d,e.

The SQL UNION operator combines two or more SELECT statements.

The SQL UNION Operator
The UNION operator is used to combine the result-set of two or more SELECT statements.
Notice that each SELECT statement within the UNION must have the same number of columns. The columns must also
have similar data types. Also, the columns in each SELECT statement must be in the same order.
SQL UNION Syntax
SELECT column_name(s) FROM table_name1
UNION
SELECT column_name(s) FROM table_name2

Note: The UNION operator selects only distinct values by default. To allow duplicate values, use UNION ALL.
SQL UNION ALL Syntax
SELECT column_name(s) FROM table_name1
UNION ALL
SELECT column_name(s) FROM table_name2
PS: The column names in the result-set of a UNION are always equal to the column names in the first SELECT statement
in the UNION.
SQL UNION Example
Look at the following tables:
"Employees_Norway":
E_ID
01
02
03
04

E_Name
Hansen, Ola
Svendson, Tove
Svendson, Stephen
Pettersen, Kari

"Employees_USA":
E_ID
01
02
03
04

E_Name
Turner, Sally
Kent, Clark
Svendson, Stephen
Scott, Stephen

Now we want to list all the different employees in Norway and USA.
We use the following SELECT statement:
SELECT E_Name FROM Employees_Norway
UNION
SELECT E_Name FROM Employees_USA
The result-set will look like this:
E_Name
Hansen, Ola
Svendson, Tove
Svendson, Stephen
Pettersen, Kari
Turner, Sally
Kent, Clark
Scott, Stephen
Note: This command cannot be used to list all employees in Norway and USA. In the example above we have two
employees with equal names, and only one of them will be listed. The UNION command selects only distinct values.

SQL UNION ALL Example

Now we want to list all employees in Norway and USA:
SELECT E_Name FROM Employees_Norway
UNION ALL
SELECT E_Name FROM Employees_USA
Result
E_Name
Hansen, Ola
Svendson, Tove
Svendson, Stephen
Pettersen, Kari
Turner, Sally
Kent, Clark
Svendson, Stephen
Scott, Stephen
What arethedifference between DDL, DMLand DCLcommands?
DML
DML is abbreviation of Data Manipulation Language. It is used to retrieve, store, modify, delete, insert and update data
in database.
Examples: SELECT, UPDATE, INSERT statements
DDL
DDL is abbreviation of Data Definition Language. It is used to create and modify the structure of database objects in
database.
Examples: CREATE, ALTER, DROP statements
DCL
DCL is abbreviation of Data Control Language. It is used to create roles, permissions, and referential integrity as well it
is used to control access to database by securing it.
Examples: GRANT, REVOKE statements
TCL
TCL is abbreviation of Transactional Control Language. It is used to manage different transactions occurring within a
database.
Examples: COMMIT, ROLLBACK statements
DDL
Data Definition Language (DDL) statements are used to define the database structure or schema. Some examples:

o
o
o
o
o
o

CREATE - to create objects in the database

ALTER - alters the structure of the database
DROP - delete objects from the database
TRUNCATE - remove all records from a table, including all spaces allocated for the records are removed
COMMENT - add comments to the data dictionary
RENAME - rename an object

DML
Data Manipulation Language (DML) statements are used for managing data within schema objects. Some examples:
o SELECT - retrieve data from the a database
o INSERT - insert data into a table
o UPDATE - updates existing data within a table
o DELETE - deletes all records from a table, the space for the records remain
o MERGE - UPSERT operation (insert or update)
o CALL - call a PL/SQL or Java subprogram
o EXPLAIN PLAN - explain access path to data
o LOCK TABLE - control concurrency
DCL
Data Control Language (DCL) statements. Some examples:
o GRANT - gives user's access privileges to database
o REVOKE - withdraw access privileges given with the GRANT command
TCL
Transaction Control (TCL) statements are used to manage the changes made by DML statements. It allows statements to
be grouped together into logical transactions.
o COMMIT - save work done
o SAVEPOINT - identify a point in a transaction to which you can later roll back
o ROLLBACK - restore database to original since the last COMMIT
o SET TRANSACTION - Change transaction options like isolation level and what rollback segment to use
DDL COMMANDS:
CREATE,ALTER,DROP AND TRUNCATE ARE CALLED DDL COMMANDS. They are called Data Definition since
they are used for defining the data. That is the structure of the data is known through these DDL commands.
DML COMMANDS:
DML commands are used for data manipulation. Some of the DML commands
insert,select,update,delete etc. Even though select is not exactly a DML language command oracle still recommends you to
consider SELECT as an DML command.
TCL:
For revoking the transactions and to make the data commit to the database we use TCL. Some of the TCL commands are:
1. ROLLBACK
2. COMMIT
ROLLBACK is used for revoking the transactions until last commit.
COMMIT is used for commiting the transactions to the database.
Once we commit we cannot rollback. Once we rollback we cannot commit.
Commit and Rollback are generally used to commit or revoke the transactions that are with regard to DML commands.
DCL:
Data Control Language is used for the control of data. That is a user can access any data based on the priveleges given to
him. This is done through DATA CONTROL LANGUAGE. Some of the DCL Commands are:
1. GRANT
2. REVOKE

Difference between DELETE, TRUNCATE and DROP

DELETE

TRUNCATE

DROP

Deletes some or all rows of

a table

Deletes all rows of a table

Removes all rows and also

the table definition,
including indexes, triggers,
grants, storage parameters

Command Type

DML

DDL

DDL

Space Usage and

Release

Uses UNDO space.

Does not use UNDO

space.

Does not use UNDO space.

Released blocks that go to

the freelist for the table, to
be used for subsequent
inserts/updates. Does not
deallocate space.

Deallocates all space used

by the table except
MINEXTENTS.

Unless the PURGE clause

is specified, does not result
in space being released.

Yes

No

No

Uncommitted deletes can

be rolled back

Cannot be rolled back

once truncated, gone
forever

A dropped table can be

reinstated from the recycle
bin (more on this in a
future article)

Selective deletion
possible?

Yes. Filter criteria be

specified via WHERE
clause

No filter criteria allowed,

removes all rows

No filter criteria allowed,

removes all rows

Triggers fired?

Yes, DELETE triggers

fired

No triggers fired

No triggers fired

Can delete data even if

FKs are enabled, provided
the data violates no FK
constraint

Cannot delete data if FKs

are enabled; FKs need to
be disabled/dropped.

Can drop the table with the

CASCADE
CONSTRAINTS option.
This will also remove the
associated FKs

Purpose

Commit required?
Undo possible?

What if foreign keys

(FKs) based on the
table exist?

Exception: Truncate is
possible if the FK is selfreferential.

Efficiency

Privileges required to
issue the command

DELETE can be slow

especially if the table has
many triggers, indexes,and
other dependencies

TRUNCATE is most
efficient for deleting all
rows, even more than
dropping and recreating
the table using DROP

DROP may not be as

efficient as TRUNCATE,
as dropping and re-creating
the table requires you to regrant object privileges, recreate indexes, constraints,
etc.

DELETE privilege.

DROP ANY TABLE

system privilege.

DROP ANY TABLE

system privilege.

DELETE ANY TABLE

allows you to delete rows
from any table of any
schema.
Grants

DELETE privilege on a
specific table can be
granted to another user or
role.

TRUNCATE privilege on a
specific table cannot be
granted to another user or
role.

DROP ANY privilege on a

specific table cannot be
granted to another user or
role.

Can work outside the

users schema?

Yes, as long as the user has

the DELETE privilege on
the object.

No. A table can be

truncated in ones own
schema only.

No. A table can be dropped

in ones own schema only.

Can work on a table

that is part of a
cluster?

Yes

No. You will have to

truncate the whole cluster,
or use either DELETE or
DROP.

Yes

The DELETE command is used to remove rows from a table. A WHERE clause can be used to only remove some rows. If
no WHERE condition is specified, all rows will be removed. After performing a DELETE operation you need to
COMMIT or ROLLBACK the transaction to make the change permanent or to undo it.
TRUNCATE removes all rows from a table. The operation cannot be rolled back. As such, TRUCATE is faster and doesn't
use as much undo space as a DELETE.
The DROP command removes a table from the database. All the tables' rows,
indexes and privileges will also be removed. The operation cannot be rolled back.
DROP and TRUNCATE are DDL commands, whereas DELETE is a DML command. Therefore DELETE operations can
be rolled back (undone), while DROP and TRUNCATE operations cannot be rolled back.

The delete statement will result in the table spaces or memories would remain as the current size and table structure remain
in the database. Delete is not effective when you use it to remove all data from a table because it takes up storeage spaces
due to unclear memories. The truncate statement will result in clearing table spaces or memories and the table structure
remain in the database. Therefore it free table storage spaces and only use it when you need to remove all data from a table.
The drop statement will result in completely removing the table from the database. Note: Statements above are made with
the assumption that a commit is has been executed. Once a commit statement is executed (commit is final). Therefore
rollback a transaction will not work if commit statement is executed.
DELETE

The DELETE command is used to remove rows from a table. A WHERE clause can be used to only remove some rows. If
no WHERE condition is specified, all rows will be removed. After performing a DELETE operation you need to COMMIT
or ROLLBACK the transaction to make the change permanent or to undo it. Note that this operation will cause all
DELETE triggers on the table to fire.
SQL> SELECT COUNT(*) FROM emp;
COUNT(*)
---------14
SQL> DELETE FROM emp WHERE job = 'CLERK';
4 rows deleted.
SQL> COMMIT;
Commit complete.
SQL> SELECT COUNT(*) FROM emp;
COUNT(*)
---------10
TRUNCATE
TRUNCATE removes all rows from a table. The operation cannot be rolled back and no triggers will be fired. As such,
TRUCATE is faster and doesn't use as much undo space as a DELETE.
SQL> TRUNCATE TABLE emp;
Table truncated.
SQL> SELECT COUNT(*) FROM emp;
COUNT(*)
---------0
DROP
The DROP command removes a table from the database. All the tables' rows, indexes and privileges will also be removed.
No DML triggers will be fired. The operation cannot be rolled back.
SQL> DROP TABLE emp;
Table dropped.
SQL> SELECT * FROM emp;
SELECT * FROM emp
*
ERROR at line 1:
ORA-00942: table or view does not exist

DROP and TRUNCATE are DDL commands, whereas DELETE is a DML command. Therefore DELETE operations can
be rolled back (undone), while DROP and TRUNCATE operations cannot be rolled back.
DELETE
Delete is the command that only remove the data from the table. It is DML statement. Deleted data can be rollback. By
using this we can delete whole data from the table(if use without where clause).If ew want to remove only selected data
then we should specify condition in the where clause
SQL>delete from employee;(this command will remove all the data from table)
SQL>delete from employee where employee_name='JOHN';(This command will remove only that row from employee
table where employee_name is JOHN');
DROP:
Drop command remove the table from data dictionary. This is the DDL statement. We can not recover the table before
Oracle 10g. But Oracle 10g provide the command to recover it by using the command (FLASHBACK)
TRUNCATE:
This is the DML command. This command delete the data from table. But there is one difference from ordinary delete
command. Truncate command drop the storage held by this table. Drop storage can be use by this table again or some other
table. This is the faster command because it directly drop the storage

SQL Delete Statement

The DELETE Statement is used to delete rows from a table.
The Syntax of a SQL DELETE statement is:
DELETE FROM table_name [WHERE condition];

table_name -- the table name which has to be updated.

NOTE:The WHERE clause in the sql delete command is optional and it identifies the rows in the column that gets
deleted. If you do not include the WHERE clause all the rows in the table is deleted, so be careful while writing a
DELETE query without WHERE clause.
For Example: To delete an employee with id 100 from the employee table, the sql delete query would be like,
DELETE FROM employee WHERE id = 100;
To delete all the rows from the employee table, the query would be like,
DELETE FROM employee;
SQL TRUNCATE Statement
The SQL TRUNCATE command is used to delete all the rows from the table and free the space containing the table.
Syntax to TRUNCATE a table:
TRUNCATE TABLE table_name;
For Example: To delete all the rows from employee table, the query would be like,
TRUNCATE TABLE employee;
Difference between DELETE and TRUNCATE Statements:
DELETE Statement: This command deletes only the rows from the table based on the condition given in the where clause
or deletes all the rows from the table if no condition is specified. But it does not free the space containing the table.
TRUNCATE statement: This command is used to delete all the rows from the table and free the space containing the
table.

SQL DROP Statement:

The SQL DROP command is used to remove an object from the database. If you drop a table, all the rows in the table is
deleted and the table structure is removed from the database. Once a table is dropped we cannot get it back, so be careful
while using RENAME command. When a table is dropped all the references to the table will not be valid.
Syntax to drop a sql table structure:

DROP TABLE table_name;

For Example: To drop the table employee, the query would be like
DROP TABLE employee;
Difference between DROP and TRUNCATE Statement:
If a table is dropped, all the relationships with other tables will no longer be valid, the integrity constraints will be dropped,
grant or access privileges on the table will also be dropped, if want use the table again it has to be recreated with the
integrity constraints, access privileges and the relationships with other tables should be established again. But, if a table is
truncated, the table structure remains the same, therefore any of the above problems will not exist.
difference between inner and outer join

An inner join of A and B gives the result of A intersect B, i.e. the inner part of a venn diagram intersection.

An outer join of A and B gives the results of A union B, i.e. the outer parts of a venn diagram union.

Examples
Suppose you have two Tables, with a single column each, and data as follows:
A
1
2
3
4

B
3
4
5
6

Note that (1,2) are unique to A, (3,4) are common, and (5,6) are unique to B.
inner join
An inner join using either of the equivalent queries gives the intersection of the two tables, i.e. the two rows they have in
common.
select * from a INNER JOIN b on a.a = b.b;
select a.*,b.* from a,b where a.a = b.b;
a|b
--+-3|3
4|4
left outer join
A left outer join will give all rows in A, plus any common rows in B.
select * from a LEFT OUTER JOIN b on a.a = b.b;
select a.*,b.* from a,b where a.a = b.b(+);
a| b
--+----1 | null
2 | null

3|
4|

3
4

full outer join

A full outer join will give you the union of A and B, i.e. All the rows in A and all the rows in B. If something in A doesn't
have a corresponding datum in B, then the B portion is null, and vice versa.
select * from a FULL OUTER JOIN b on a.a = b.b;
a | b
-----+----1 | null
2 | null
3| 3
4| 4
null | 6
null | 5

Joins
A join is a query that combines rows from two or more tables, views, or materialized views. Oracle Database performs a
join whenever multiple tables appear in the FROM clause of the query. The select list of the query can select any columns
from any of these tables. If any two of these tables have a column name in common, then you must qualify all references to
these columns throughout the query with table names to avoid ambiguity.
Join Conditions
Most join queries contain at least one join condition, either in the FROM clause or in the WHERE clause. The join
condition compares two columns, each from a different table. To execute a join, Oracle Database combines pairs of rows,
each containing one row from each table, for which the join condition evaluates to TRUE. The columns in the join
conditions need not also appear in the select list.
To execute a join of three or more tables, Oracle first joins two of the tables based on the join conditions comparing their
columns and then joins the result to another table based on join conditions containing columns of the joined tables and the
new table. Oracle continues this process until all tables are joined into the result. The optimizer determines the order in
which Oracle joins tables based on the join conditions, indexes on the tables, and, any available statistics for the tables.
IA WHERE clause that contains a join condition can also contain other conditions that refer to columns of only one table.
These conditions can further restrict the rows returned by the join query.
Note:
You cannot specify LOB columns in the WHERE clause if the WHERE clause contains the join condition. The use of
LOBs in WHERE clauses is also subject to other restrictions. See Oracle Database SecureFiles and Large Objects
Developer's Guide for more information.
Equijoins
An equijoin is a join with a join condition containing an equality operator. An equijoin combines rows that have equivalent
values for the specified columns. Depending on the internal algorithm the optimizer chooses to execute the join, the total
size of the columns in the equijoin condition in a single table may be limited to the size of a data block minus some
overhead. The size of a data block is specified by the initialization parameter DB_BLOCK_SIZE.
See Also:
"Using Join Queries: Examples"

Self Joins
A self join is a join of a table to itself. This table appears twice in the FROM clause and is followed by table aliases that
qualify column names in the join condition. To perform a self join, Oracle Database combines and returns rows of the table
that satisfy the join condition.
See Also:
"Using Self Joins: Example"
Cartesian Products
If two tables in a join query have no join condition, then Oracle Database returns their Cartesian product. Oracle
combines each row of one table with each row of the other. A Cartesian product always generates many rows and is rarely
useful. For example, the Cartesian product of two tables, each with 100 rows, has 10,000 rows. Always include a join
condition unless you specifically need a Cartesian product. If a query joins three or more tables and you do not specify a
join condition for a specific pair, then the optimizer may choose a join order that avoids producing an intermediate
Cartesian product.
Inner Joins
An inner join (sometimes called a simple join) is a join of two or more tables that returns only those rows that satisfy the
join condition.
Outer Joins
An outer join extends the result of a simple join. An outer join returns all rows that satisfy the join condition and also
returns some or all of those rows from one table for which no rows from the other satisfy the join condition.

To write a query that performs an outer join of tables A and B and returns all rows from A (a left outer join), use
the LEFT [OUTER] JOIN syntax in the FROM clause, or apply the outer join operator (+) to all columns of B in
the join condition in the WHERE clause. For all rows in A that have no matching rows in B, Oracle Database
returns null for any select list expressions containing columns of B.
To write a query that performs an outer join of tables A and B and returns all rows from B (a right outer join), use
the RIGHT [OUTER] JOIN syntax in the FROM clause, or apply the outer join operator (+) to all columns of A in
the join condition in the WHERE clause. For all rows in B that have no matching rows in A, Oracle returns null
for any select list expressions containing columns of A.
To write a query that performs an outer join and returns all rows from A and B, extended with nulls if they do not
satisfy the join condition (a full outer join), use the FULL [OUTER] JOIN syntax in the FROM clause.

You cannot compare a column with a subquery in the WHERE clause of any outer join, regardless which form you specify.
You can use outer joins to fill gaps in sparse data. Such a join is called a partitioned outer join and is formed using the
query_partition_clause of the join_clause syntax. Sparse data is data that does not have rows for all possible values of a
dimension such as time or department. For example, tables of sales data typically do not have rows for products that had no
sales on a given date. Filling data gaps is useful in situations where data sparsity complicates analytic computation or
where some data might be missed if the sparse data is queried directly.

See Also:

join_clause for more information about using outer joins to fill gaps in sparse data
Oracle Database Data Warehousing Guide for a complete discussion of group outer joins and filling gaps in
sparse data

Oracle recommends that you use the FROM clause OUTER JOIN syntax rather than the Oracle join operator. Outer join
queries that use the Oracle join operator (+) are subject to the following rules and restrictions, which do not apply to the
FROM clause OUTER JOIN syntax:

You cannot specify the (+) operator in a query block that also contains FROM clause join syntax.
The (+) operator can appear only in the WHERE clause or, in the context of left-correlation (when specifying the
TABLE clause) in the FROM clause, and can be applied only to a column of a table or view.

If A and B are joined by multiple join conditions, then you must use the (+) operator in all of these conditions. If
you do not, then Oracle Database will return only the rows resulting from a simple join, but without a warning or
error to advise you that you do not have the results of an outer join.

The (+) operator does not produce an outer join if you specify one table in the outer query and the other table in an
inner query.

You cannot use the (+) operator to outer-join a table to itself, although self joins are valid. For example, the
following statement is not valid:

-- The following statement is not valid:

SELECT employee_id, manager_id
FROM employees
WHERE employees.manager_id(+) = employees.employee_id;
However, the following self join is valid:
SELECT e1.employee_id, e1.manager_id, e2.employee_id
FROM employees e1, employees e2
WHERE e1.manager_id(+) = e2.employee_id
ORDER BY e1.employee_id, e1.manager_id, e2.employee_id;

The (+) operator can be applied only to a column, not to an arbitrary expression. However, an arbitrary expression
can contain one or more columns marked with the (+) operator.
A WHERE condition containing the (+) operator cannot be combined with another condition using the OR logical
operator.
A WHERE condition cannot use the IN comparison condition to compare a column marked with the (+) operator
with an expression.

If the WHERE clause contains a condition that compares a column from table B with a constant, then the (+) operator must
be applied to the column so that Oracle returns the rows from table A for which it has generated nulls for this column.
Otherwise Oracle returns only the results of a simple join.
In a query that performs outer joins of more than two pairs of tables, a single table can be the null-generated table for only
one other table. For this reason, you cannot apply the (+) operator to columns of B in the join condition for A and B and the
join condition for B and C. Refer to SELECT for the syntax for an outer join.
Antijoins
An antijoin returns rows from the left side of the predicate for which there are no corresponding rows on the right side of
the predicate. It returns rows that fail to match (NOT IN) the subquery on the right side.
See Also:
"Using Antijoins: Example"
Semijoins
A semijoin returns rows that match an EXISTS subquery without duplicating rows from the left side of the predicate when
multiple rows on the right side satisfy the criteria of the subquery.
Semijoin and antijoin transformation cannot be done if the subquery is on an OR branch of the WHERE clause.

What is the difference between Modify, Insert, Update commands

Modiy is used to edit and change the existing record. In case of database table if the record exist then it will try to modiy
otherwise it will inser new record.
Insert is used to insert a record in the tabel in a speicified place.
Update is used to change the existing record.
INSERT - inserts a new record. INSERT expects that a record with the required key does NOT exist in the table.
Therefore, if a record with the same key already exists, a runtime error occurs. For more details on INSERT, visit here.
UPDATE - update an existing record. UPDATE expects that a record with required key exists in the table. If a record with
the required key does not exist, it issue an error (sy-subrc is 4). For more details on UPDATE, visit here.
MODIFY - acts like a combination of INSERT and UPDATE. If a record with the specified key does not exist, it adds it to
the table. If a record with the specified key does exist, it modifies it. So MODIFY actually acts like "Insert or change
record". To read more about MODIFY, visit here.
To summarize:
INSERT - adds a new record to the table. If the row (key) exists, issues an error.
UPDATE - updates an existing record to the table. If the row (key) does not exist, issues an error.
MODIFY - If the key exists, modifies the record. If the key does not exist, adds the record to the table.
SQL Integrity Constraints
Integrity Constraints are used to apply business rules for the database tables.
The constraints available in SQL are Foreign Key, Not Null, Unique, Check.
Constraints can be defined in two ways
1) The constraints can be specified immediately after the column definition. This is called column-level definition.
2) The constraints can be specified after all the columns are defined. This is called table-level definition.
1) SQL Primary key:
This constraint defines a column or combination of columns which uniquely identifies each row in the table.
Syntax to define a Primary key at column level:
column name datatype [CONSTRAINT constraint_name] PRIMARY KEY
Syntax to define a Primary key at table level:
[CONSTRAINT constraint_name] PRIMARY KEY (column_name1,column_name2,..)

column_name1, column_name2 are the names of the columns which define the primary Key.

The syntax within the bracket i.e. [CONSTRAINT constraint_name] is optional.

For Example: To create an employee table with Primary Key constraint, the query would be like.

Primary Key at table level:

CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
salary number(10),
location char(10)
);
or
CREATE TABLE employee
( id number(5) CONSTRAINT emp_id_pk PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
salary number(10),
location char(10)
);
Primary Key at table level:
CREATE TABLE employee
( id number(5),
name char(20),
dept char(10),
age number(2),
salary number(10),
location char(10),
CONSTRAINT emp_id_pk PRIMARY KEY (id)
);
2) SQL Foreign key or Referential Integrity :
This constraint identifies any column referencing the PRIMARY KEY in another table. It establishes a relationship
between two columns in the same table or between different tables. For a column to be defined as a Foreign Key, it should
be a defined as a Primary Key in the table which it is referring. One or more columns can be defined as Foreign key.
Syntax to define a Foreign key at column level:
[CONSTRAINT constraint_name] REFERENCES Referenced_Table_name(column_name)
Syntax to define a Foreign key at table level:
[CONSTRAINT constraint_name] FOREIGN KEY(column_name) REFERENCES
referenced_table_name(column_name);

For Example:

1) Lets use the "product" table and "order_items".

Foreign Key at column level:
CREATE TABLE product
( product_id number(5) CONSTRAINT pd_id_pk PRIMARY KEY,
product_name char(20),
supplier_name char(20),
unit_price number(10)
);
CREATE TABLE order_items
( order_id number(5) CONSTRAINT od_id_pk PRIMARY KEY,
product_id number(5) CONSTRAINT pd_id_fk REFERENCES, product(product_id),
product_name char(20),
supplier_name char(20),
unit_price number(10)
);
Foreign Key at table level:
CREATE TABLE order_items
( order_id number(5) ,
product_id number(5),
product_name char(20),
supplier_name char(20),
unit_price number(10)
CONSTRAINT od_id_pk PRIMARY KEY(order_id),
CONSTRAINT pd_id_fk FOREIGN KEY(product_id) REFERENCES product(product_id)
);
2) If the employee table has a 'mgr_id' i.e, manager id as a foreign key which references primary key 'id' within the same
table, the query would be like,
CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
mgr_id number(5) REFERENCES employee(id),
salary number(10),
location char(10)
);
3) SQL Not Null Constraint :
This constraint ensures all rows in the table contain a definite value for the column which is specified as not null. Which
means a null value is not allowed.
Syntax to define a Not Null constraint:
[CONSTRAINT constraint name] NOT NULL

For Example: To create a employee table with Null value, the query would be like
CREATE TABLE employee
( id number(5),
name char(20) CONSTRAINT nm_nn NOT NULL,
dept char(10),

age number(2),
salary number(10),
location char(10)
);
4) SQL Unique Key:
This constraint ensures that a column or a group of columns in each row have a distinct value. A column(s) can have a null
value but the values cannot be duplicated.
Syntax to define a Unique key at column level:
[CONSTRAINT constraint_name] UNIQUE
Syntax to define a Unique key at table level:
[CONSTRAINT constraint_name] UNIQUE(column_name)
For Example: To create an employee table with Unique key, the query would be like,
Unique Key at column level:
CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
salary number(10),
location char(10) UNIQUE
); or
CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
salary number(10),
location char(10) CONSTRAINT loc_un UNIQUE
);
Unique Key at table level:
CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
salary number(10),
location char(10),
CONSTRAINT loc_un UNIQUE(location)
);
5) SQL Check Constraint :
This constraint defines a business rule on a column. All the rows must satisfy this rule. The constraint can be applied for a
single column or a group of columns.
Syntax to define a Check constraint:

[CONSTRAINT constraint_name] CHECK (condition)

For Example: In the employee table to select the gender of a person, the query would be like
Check Constraint at column level:
CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
gender char(1) CHECK (gender in ('M','F')),
salary number(10),
location char(10)
);
Check Constraint at table level:
CREATE TABLE employee
( id number(5) PRIMARY KEY,
name char(20),
dept char(10),
age number(2),
gender char(1),
salary number(10),
location char(10),
CONSTRAINT gender_ck CHECK (gender in ('M','F'))
);
Referential integrity
Referential integrity is a database concept that ensures that relationships between tables remain consistent. When one table
has a foreign key to another table, the concept of referential integrity states that you may not add a record to the table that
contains the foreign key unless there is a corresponding record in the linked table. It also includes the techniques known as
cascading update and cascading delete, which ensure that changes made to the linked table are reflected in the primary
table.
Consider the situation where we have two tables: Employees and Managers. The Employees table has a foreign key
attribute entitled ManagedBy which points to the record for that employees manager in the Managers table. Referential
integrity enforces the following three rules:
We may not add a record to the Employees table unless the ManagedBy attribute points to a valid record in the Managers
table.
If the primary key for a record in the Managers table changes, all corresponding records in the Employees table must be
modified using a cascading update.
If a record in the Managers table is deleted, all corresponding records in the Employees table must be deleted using a
cascading delete.
A REFERENTIAL INTEGRITY is a database concept that is used to build and maintain logical relationships between
tables to avoid logical corruption of data. It is a very useful and important part in RDBMS.
Usually referential integrity is made up by the combination of a primary key and a foreign key.
The main concept of REFERENTIAL INTEGRITY is that, it does not allow to add any record in a table that contains
the foreign key unless the reference table containing a corresponding primary key.
If any record in referenced table (i.e. the table who contain primary key) is deleted, all the corresponding records in the
referencing table will be deleted for the referential integrity.

How to find out duplicate records in sql server?

we have to use the group by with having command to get the duplicate values. this query shall show the result of only the
users have duplicate values in the employee table.
Syntex:
Select columnName From Table_name
Group By columnName
Having count (*) > 1
Example:
SELECT UserID FROM employee
GROUP BY userid
HAVING count( * ) > 1
select *
from table
group by key1, key2, ..., keyN
having count (*) > 1;