SQL Tutorial for BCA-2

1
SQL Tutorial
Overview:
Structured Query Language(SQL) is a language of database, it includes database creation,
deletion, fetching rows and modifying rows etc. SQL is an ANSI (American National Standards
Institute) standard, but there are many different versions of the SQL language.
What is SQL?
SQL is Structured Query Language, which is a computer language for storing, manipulating and
retrieving data stored in relational database. SQL is the standard language for Relation Database
System. All relational database management systems like MySQL, MS Access, Oracle, Sybase,
Informix, postgres and SQL Server use SQL as standard database language. Also, they are using
different dialects, such as:
 MS SQL Server using T-SQL,
 Oracle using PL/SQL,
 MS Access version of SQL is called JET SQL (native format) etc.
Why SQL?
 Allows users to access data in relational database management systems.
 Allows users to describe the data.
 Allows users to define the data in database and manipulate that data.
 Allows to embed within other languages using SQL modules, libraries & pre-compilers.
 Allows users to create and drop databases and tables.
 Allows users to create view, stored procedure, functions in a database.
 Allows users to set permissions on tables, procedures and views
History:
 1970 -- Dr. E. F. "Ted" of IBM is known as the father of relational databases. He
described a relational model for databases.
 1974 -- Structured Query Language appeared.
 1978 -- IBM worked to develop Codd's ideas and released a product named System/R.
 1986 -- IBM developed the first prototype of relational database and standardized by
ANSI. The first relational database was released by Relational Software and its later
becoming Oracle.
SQL Process:
When we are executing an SQL command for any RDBMS, the system determines the best way
to carry out our request and SQL engine figures out how to interpret the task. There are various
components included in the process. These components are Query Dispatcher, Optimization
Engines, Classic Query Engine and SQL Query Engine, etc. Classic query engine handles all
non-SQL queries, but SQL query engine won't handle logical files.
Following is a simple diagram showing SQL Architecture:

2
SQL Commands:
The standard SQL commands to interact with relational databases are CREATE, SELECT,
INSERT, UPDATE, DELETE and DROP. These commands can be classified into groups based
on their nature:
1. DDL-Data Definition Language:
Command Description
CREATE Creates a new table, a view of a table, or other object in database
ALTER Modifies an existing database object, such as a table.
DROP Deletes an entire table, a view of a table or other object in the
database.
2. DML-Data Manipulation Language:
Command Description
INSERT Creates a record
UPDATE Modifies records
DELETE Deletes records
3. DCL -Data Control Language:
Command Description
GRANT Gives a privilege to user
REVOKE Takes back privileges granted from user
4. DQL -Data Query Language:
Command Description
SELECT Retrieves certain records from one or more tables

3
1. DDL-Data Definition Language: It is a set of SQL Commands used to create , modify
and delete database structure but not data.
i) SQL CREATE Table
Creating a basic table involves naming the table and defining its columns and each column's data
type. The SQL CREATE TABLE statement is used to create a new table.
Syntax: Basic syntax of CREATE TABLE statement is as follows:
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);
CREATE TABLE is the keyword telling the database system what we want to do. In this case,
we want to create a new table. The unique name or identifier for the table follows the CREATE
TABLE statement.
Then in brackets comes the list defining each column in the table and what sort of data type it is.
The syntax becomes clearer with an example below.
A copy of an existing table can be created using a combination of the CREATE TABLE
statement and the SELECT statement. We can check complete details at Create Table Using
another Table.
Create Table Using another Table
A copy of an existing table can be created using a combination of the CREATE TABLE
statement and the SELECT statement. The new table has the same column definitions. All
columns or specific columns can be selected.
When we create a new table using existing table, new table would be populated using existing
values in the old table.
Syntax: The basic syntax for creating a table from another table is as follows:
CREATE TABLE NEW_TABLE_NAME AS
SELECT [ column1, column2...columnN ]
FROM EXISTING_TABLE_NAME
[ WHERE ]
Here, column1, column2...are the fields of existing table and same would be used to create fields
of new table. Following is an example, which would create a table SALARY using
CUSTOMERS table and having fields customer ID and customer SALARY:
SQL> CREATE TABLE SALARY AS SELECT ID, SALARY FROM CUSTOMERS;
This would create new table SALARY, which would have the following records:

4
+----+----------+
| ID | SALARY |
+----+----------+
| 1 | 2000.00 |
| 2 | 1500.00 |
| 3 | 2000.00 |
| 4 | 6500.00 |
| 5 | 8500.00 |
| 6 | 4500.00 |
| 7 | 10000.00 |
+----+----------+
Example:
Following is an example, which creates a CUSTOMERS table with ID as primary key and NOT
NULL are the constraints showing that these fileds can not be NULL while creating records in
this table:
SQL> CREATE TABLE CUSTOMERS( ID INT NOT NULL, NAME VARCHAR (20)
NOT NULL, AGE INT NOT NULL, ADDRESS CHAR (25) , SALARY DECIMAL (18, 2),
PRIMARY KEY (ID) );
We can verify if our table has been created successfully by looking at the message displayed by
the SQL server, otherwise we can use DESC command as follows:
SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | | |
| SALARY | decimal(18,2) | YES | | | |
ii) SQL ALTER TABLE Command:
The SQL ALTER TABLE command is used to add, delete or modify columns in an existing
table. We would also use ALTER TABLE command to add and drop various constraints on an
existing table.
Syntax:
The basic syntax of ALTER TABLE to add a new column in an existing table is as follows:
ALTER TABLE table_name ADD column_name datatype;
The basic syntax of ALTER TABLE to DROP COLUMN in an existing table is as follows:

5
ALTER TABLE table_name DROP COLUMN column_name;
The basic syntax of ALTER TABLE to change the DATA TYPE of a column in a table is as
follows:
ALTER TABLE table_name MODIFY COLUMN column_name datatype;
The basic syntax of ALTER TABLE to add a NOT NULL constraint to a column in a table is as
follows:
ALTER TABLE table_name MODIFY column_name datatype NOT NULL;
The basic syntax of ALTER TABLE to ADD UNIQUE CONSTRAINT to a table is as follows:
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);
The basic syntax of ALTER TABLE to ADD CHECK CONSTRAINT to a table is as follows:
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);
The basic syntax of ALTER TABLE to ADD PRIMARY KEY constraint to a table is as
follows:
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1,
column2...);
The basic syntax of ALTER TABLE to DROP CONSTRAINT from a table is as follows:
DROP CONSTRAINT MyUniqueConstraint;
If we're using MySQL, the code is as follows:
DROP INDEX MyUniqueConstraint;
The basic syntax of ALTER TABLE to DROP PRIMARY KEY constraint from a table is as
follows:
DROP CONSTRAINT MyPrimaryKey;
If we're using MySQL, the code is as follows:
DROP PRIMARY KEY;
Example: Consider the CUSTOMERS table having the following records:
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+

6
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is the example to ADD a new column in an existing table:
ALTER TABLE CUSTOMERS ADD SEX char(1);
Now, CUSTOMERS table is changed and following would be output from SELECT statement:
+----+---------+-----+-----------+----------+------+
| ID | NAME | AGE | ADDRESS | SALARY | SEX |
+----+---------+-----+-----------+----------+------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | NULL |
| 2 | Ramesh | 25 | Delhi | 1500.00 | NULL |
| 3 | kaushik | 23 | Kota | 2000.00 | NULL |
| 4 | kaushik | 25 | Mumbai | 6500.00 | NULL |
| 5 | Hardik | 27 | Bhopal | 8500.00 | NULL |
| 6 | Komal | 22 | MP | 4500.00 | NULL |
| 7 | Muffy | 24 | Indore | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+
Following is the example to DROP sex column from existing table:
ALTER TABLE CUSTOMERS DROP SEX;
Now, CUSTOMERS table is changed and following would be output from SELECT statement:
+----+---------+-----+-----------+----------+
+----+---------+-----+-----------+----------+
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
iii) SQL DROP or DELETE Table
The SQL DROP TABLE statement is used to remove a table definition and all data, indexes,
triggers, constraints, and permission specifications for that table.
NOTE: We have to be careful while using this command because once a table is deleted then all
the information available in the table would also be lost forever.
Syntax:
Basic syntax of DROP TABLE statement is as follows:
DROP TABLE table_name;

7
Example:
Let us first verify CUSTOMERS table and then we would delete it from the database:
+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | NULL | |
| SALARY | decimal(18,2) | YES | | NULL | |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)
This means CUSTOMERS table is available in the database, so let us drop it as follows:
SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)
Now, if we would try DESC command, then we would get error as follows:
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist
Here, TEST is database name which we are using for our examples
2. DML-Data Manipulation Language: It is a set of SQL Commands that allows changing data
within the database.
i) SQL INSERT Query
The SQL INSERT INTO Statement is used to add new rows of data to a table in the database.
Syntax:
There are two basic syntaxes of INSERT INTO statement as follows:
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)]
VALUES (value1, value2, value3,...valueN);
Here, column1, column2,...columnN are the names of the columns in the table into which we
want to insert data.
We may not need to specify the column(s) name in the SQL query if we are adding values for all
the columns of the table. But make sure the order of the values is in the same order as the
columns in the table. The SQL INSERT INTO syntax would be as follows:
INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);
Example:
Following statements would create six records in CUSTOMERS table:

8
INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );
VALUES (6, 'Komal', 22, 'MP', 4500.00 );
We can create a record in CUSTOMERS table using second syntax as follows:
INSERT INTO CUSTOMERS VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );
All the above statements would produce the following records in CUSTOMERS table:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
ii) SQL UPDATE Query: The SQL UPDATE Query is used to modify the existing records in
a table. We can use WHERE clause with UPDATE query to update selected rows, otherwise all
the rows would be affected.
Syntax: The basic syntax of UPDATE query with WHERE clause is as follows:
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

9
We can combine N number of conditions using AND or OR operators.
Example:
Following is an example, which would update ADDRESS for a customer whose ID is 6:
SQL> UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;
Now, CUSTOMERS table would have the following records:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | Pune | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
If we want to modify all ADDRESS and SALARY column values in CUSTOMERS table, we do
not need to use WHERE clause and UPDATE query would be as follows:
SQL> UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;
+----+----------+-----+---------+---------+
+----+----------+-----+---------+---------+
| 1 | Ramesh | 32 | Pune | 1000.00 |
| 2 | Khilan | 25 | Pune | 1000.00 |
| 3 | kaushik | 23 | Pune | 1000.00 |
| 4 | Chaitali | 25 | Pune | 1000.00 |
| 5 | Hardik | 27 | Pune | 1000.00 |
| 6 | Komal | 22 | Pune | 1000.00 |
| 7 | Muffy | 24 | Pune | 1000.00 |
iii) SQL DELETE Query: The SQL DELETE Query is used to delete the existing
records from a table. We can use WHERE clause with DELETE query to delete
selected rows, otherwise all the records would be deleted.
Syntax:
The basic syntax of DELETE query with WHERE clause is as follows:
DELETE FROM table_name
WHERE [condition];
We can combine N number of conditions using AND or OR operators.
Example:

10
Consider the CUSTOMERS table having the following records:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is an example, which would DELETE a customer, whose ID is 6:
SQL> DELETE FROM CUSTOMERS WHERE ID = 6;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
If we want to DELETE all the records from CUSTOMERS table, we do not need to use WHERE
clause and DELETE query would be as follows:
SQL> DELETE FROM CUSTOMERS;
Now, CUSTOMERS table would not have any record.
3. Data Query Language
i) SQL SELECT Query
SQL SELECT Statement is used to fetch the data from a database table which returns data in the
form of result table. These result tables are called result-sets.
Syntax:
The basic syntax of SELECT statement is as follows:
SELECT column1, column2, columnN FROM table_name;
Here, column1, column2...are the fields of a table whose values we want to fetch. If we want to
fetch all the fields available in the field, then we can use the following syntax:
SELECT * FROM table_name;

11
Example:
Consider the CUSTOMERS table.
Following is an example, which would fetch ID, Name and Salary fields of the customers
available in CUSTOMERS table:
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;
This would produce the following result:
+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
If we want to fetch all the fields of CUSTOMERS table, then use the following query:
SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
ii) SQL WHERE Clause
The SQL WHERE clause is used to specify a condition while fetching the data from single table
or joining with multiple tables. If the given condition is satisfied, then only it returns specific
value from the table. We would use WHERE clause to filter the records and fetching only
necessary records. The WHERE clause is not only used in SELECT statement, but it is also used
in UPDATE, DELETE statement, etc., which we would examine in subsequent chapters.
Syntax:
The basic syntax of SELECT statement with WHERE clause is as follows:
SELECT column1, column2, columnN
FROM table_name
WHERE [condition] ;
We can specify a condition using comparison or logical operators like >, <, =, LIKE, NOT etc.
Below examples would make this concept clear.
Example:
Consider the CUSTOMERS table.

12
Following is an example, which would fetch ID, Name and Salary fields from the CUSTOMERS
table where salary is greater than 2000:
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS WHERE SALARY > 2000;
+----+----------+----------+
+----+----------+----------+
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
table for a customer with name Hardik. Here, it is important to note that all the strings should be
given inside single quotes ('') where as numeric values should be given without any quote as in
above example:
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS WHERE NAME = 'Hardik';
+----+----------+----------+
+----+----------+----------+
| 5 | Hardik | 8500.00 |
There are six main clauses in a select statement:
 FROM which tables are required for the query
 WHERE the condition to filter the required rows
 GROUP BY how to aggregate the rows
 HAVING condition to filter aggregated groups
 SELECT the required result columns, i.e. the project
 ORDER BY the ordering imposed on the result set
SQL GROUP BY Clause:
SELECT SUM(column_name) FROM table_name
WHERE CONDITION GROUP BY column_name;
SQL HAVING Clause:
WHERE CONDITION GROUP BY column_name
HAVING (arithematic function condition);
SQL ORDER BY Clause:

13
SELECT column1, column2....columnN FROM table_name
WHERE CONDITION ORDER BY column_name {ASC|DESC};
SQL RDBMS Concepts
What is RDBMS?
RDBMS stands for Relational Database Management System. RDBMS is the basis for
SQL and for all modern database systems like MS SQL Server, IBM DB2, Oracle, MySQL, and
Microsoft Access. A Relational database management system (RDBMS) is a database
management system (DBMS) that is based on the relational model as introduced by E. F. Codd.
What is table?
The data in RDBMS is stored in database objects called tables. The table is a collection
of related data entries and it consists of columns and rows. Remember, a table is the most
common and simplest form of data storage in a relational database. Following is the example of a
CUSTOMERS table:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
What is field?
Every table is broken up into smaller entities called fields. The fields in the
CUSTOMERS table consist of ID, NAME, AGE, ADDRESS and SALARY.

14
A field is a column in a table that is designed to maintain specific information about every record
in the table.
What is record or row?
A record, also called a row of data, is each individual entry that exists in a table. For
example, there are 7 records in the above CUSTOMERS table. Following is a single row of data
or record in the CUSTOMERS table:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
A record is a horizontal entity in a table.
What is column?
A column is a vertical entity in a table that contains all information associated with a
specific field in a table. For example, a column in the CUSTOMERS table is ADDRESS, which
represents location description and would consist of the following:
+-----------+
| ADDRESS |
+-----------+
| Ahmedabad |
| Delhi |
| Kota |
| Mumbai |
| Bhopal |
| MP |
| Indore |
+----+------+
What is NULL value?
A NULL value in a table is a value in a field that appears to be blank, which means a
field with a NULL value is a field with no value. It is very important to understand that a NULL
value is different than a zero value or a field that contains spaces. A field with a NULL value is
one that has been left blank during record creation.
SQL Constraints:
Constraints are the rules enforced on data columns on table. These are used to limit the
type of data that can go into a table. This ensures the accuracy and reliability of the data in the
database.
Constraints could be column level or table level. Column level constraints are applied only to
one column, whereas table level constraints are applied to the whole table.
Following are commonly used constraints available in SQL:
i. NOT NULL Constraint: Ensures that a column cannot have NULL value.
ii. DEFAULT Constraint: Provides a default value for a column when none is specified.
iii. UNIQUE Constraint: Ensures that all values in a column are different.
iv. PRIMARY Key: Uniquely identified each rows/records in a database table.
v. FOREIGN Key: Uniquely identified a rows/records in any another database table.

15
vi. CHECK Constraint: The CHECK constraint ensures that all values in a column satisfy
certain conditions.
vii. INDEX: Use to create and retrieve data from the database very quickly.
i) NOT NULL Constraint:
By default, a column can hold NULL values. If we do not want a column to have a
NULL value, then we need to define such constraint on this column specifying that NULL is
now not allowed for that column. A NULL is not the same as no data, rather, it represents
unknown data.
Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five
columns, three of which, ID and NAME and AGE, specify not to accept NULLs:
CREATE TABLE CUSTOMERS (
ID INT NOT NULL,
NAME VARCHAR (20) NOT NULL,
AGE INT NOT NULL, ADDRESS CHAR (25) ,
SALARY DECIMAL (18, 2), PRIMARY KEY (ID)
);
If CUSTOMERS table has already been created, then to add a NOT NULL constraint to
SALARY column in Oracle and MySQL, we would write a statement similar to the following:
ALTER TABLE CUSTOMERS MODIFY SALARY DECIMAL (18, 2) NOT NULL;
ii) DEFAULT Constraint:
The DEFAULT constraint provides a default value to a column when the INSERT INTO
statement does not provide a specific value. Example:
For example, the following SQL creates a new table called CUSTOMERS and adds five
columns. Here, SALARY column is set to 5000.00 by default, so in case INSERT INTO
statement does not provide a value for this column. Then by default this column would be set to
5000.00.
ID INT NOT NULL,
AGE INT NOT NULL, ADDRESS CHAR (25) ,
SALARY DECIMAL (18, 2) DEFAULT 5000.00,
PRIMARY KEY (ID)
);
If CUSTOMERS table has already been created, then to add a DEFAULT constraint to
SALARY column, we would write a statement similar to the following:

16
ALTER TABLE CUSTOMERS MODIFY SALARY DECIMAL (18, 2) DEFAULT 5000.00;
Drop Default Constraint:
To drop a DEFAULT constraint, use the following SQL:
ALTER TABLE CUSTOMERS ALTER COLUMN SALARY DROP DEFAULT;
iii) UNIQUE Constraint:
The UNIQUE Constraint prevents two records from having identical values in a particular
column. In the CUSTOMERS table, for example, we might want to prevent two or more people
from having identical age.
Example: the following SQL creates a new table called CUSTOMERS and adds five columns.
Here, AGE column is set to UNIQUE, so that we cannot have two records with same age:
ID INT NOT NULL,
AGE INT NOT NULL UNIQUE,
ADDRESS CHAR (25),
SALARY DECIMAL (18, 2),
PRIMARY KEY (ID)
);
If CUSTOMERS table has already been created, then to add a UNIQUE constraint to AGE
column, we would write a statement similar to the following:
ALTER TABLE CUSTOMERS MODIFY AGE INT NOT NULL UNIQUE;
We can also use following syntax, which supports naming the constraint in multiple columns as
well:
ALTER TABLE CUSTOMERS ADD CONSTRAINT myUniqueConstraint UNIQUE(AGE,
SALARY);
DROP a UNIQUE Constraint:
To drop a UNIQUE constraint, use the following SQL:
ALTER TABLE CUSTOMERS DROP CONSTRAINT myUniqueConstraint;
If we are using MySQL, then we can use the following syntax:
ALTER TABLE CUSTOMERS DROP INDEX myUniqueConstraint;

17
iv) PRIMARY Key:
A primary key is a field in a table which uniquely identifies each row/record in a database
table. Primary keys must contain unique values. A primary key column cannot have NULL
values. A table can have only one primary key, which may consist of single or multiple fields.
When multiple fields are used as a primary key, they are called a composite key. If a table has a
primary key defined on any field(s), then we can not have two records having the same value of
that field(s).
Create Primary Key: Here is the syntax to define ID attribute as a primary key in a
CUSTOMERS table.
ID INT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25),
PRIMARY KEY (ID)
);
To create a PRIMARY KEY constraint on the "ID" column when CUSTOMERS table already
exists, use the following SQL syntax:
ALTER TABLE CUSTOMER ADD PRIMARY KEY (ID);
NOTE: If we use the ALTER TABLE statement to add a primary key, the primary key
column(s) must already have been declared to not contain NULL values (when the table was first
created).
For defining a PRIMARY KEY constraint on multiple columns, use the following SQL syntax:
ID INT NOT NULL,
ADDRESS CHAR (25),
PRIMARY KEY (ID, NAME)
);
To create a PRIMARY KEY constraint on the "ID" and "NAMES" columns when
CUSTOMERS table already exists, use the following SQL syntax:
ALTER TABLE CUSTOMERS ADD CONSTRAINT PK_CUSTID PRIMARY KEY (ID, NAME);
Delete Primary Key: We can clear the primary key constraints from the table, Use Syntax:

18
ALTER TABLE CUSTOMERS DROP PRIMARY KEY;
v) FOREIGN Key:
A foreign key is a key used to link two tables together. This is sometimes called a referencing
key. Foreign Key is a column or a combination of columns whose values match a Primary Key in
a different table.
The relationship between 2 tables matches the Primary Key in one of the tables with a
Foreign Key in the second table. If a table has a primary key defined on any field(s), then we
cannot have two records having the same value of that field(s).
Example: Consider the structure of the two tables as follows:
CUSTOMERS table:
ID INT NOT NULL,
ADDRESS CHAR (25),
PRIMARY KEY (ID)
);
ORDERS table:
CREATE TABLE ORDERS (
ID INT NOT NULL,
DATE DATETIME,
CUSTOMER_ID INT references CUSTOMERS(ID),
AMOUNT double,
PRIMARY KEY (ID)
);
If ORDERS table has already been created, and the foreign key has not yet been set, use the
syntax for specifying a foreign key by altering a table.
ALTER TABLE ORDERS ADD FOREIGN KEY (Customer_ID) REFERENCES CUSTOMERS (ID);
DROP a FOREIGN KEY Constraint:
To drop a FOREIGN KEY constraint, use the following SQL:
ALTER TABLE ORDERS DROP FOREIGN KEY;
vi) CHECK Constraint:
The CHECK Constraint enables a condition to check the value being entered into a record. If
the condition evaluates to false, the record violates the constraint and isn’t entered into the table.

19
Example: the following SQL creates a new table called CUSTOMERS and adds five columns.
Here, we add a CHECK with AGE column, so that we can not have any CUSTOMER below 18
years:
ID INT NOT NULL,
AGE INT NOT NULL CHECK(AGE>= 18),
ADDRESS CHAR (25),
PRIMARY KEY (ID)
);
If CUSTOMERS table has already been created, then to add a CHECK constraint to AGE
column, we would write a statement similar to the following:
ALTER TABLE CUSTOMERS MODIFY AGE INT NOT NULL CHECK (AGE >= 18 );
We can also use following syntax, which supports naming the constraint in multiple columns as
well:
ALTER TABLE CUSTOMERS ADD CONSTRAINT myCheckConstraint CHECK(AGE >= 18);
DROP a CHECK Constraint:
To drop a CHECK constraint, use the following SQL. This syntax does not work with MySQL:
ALTER TABLE CUSTOMERS DROP CONSTRAINT myCheckConstraint;
INDEX:
The INDEX is used to create and retrieve data from the database very quickly. Index can be
created by using single or group of columns in a table. When index is created, it is assigned a
ROWID for each row before it sorts out the data.
Proper indexes are good for performance in large databases, but we need to be careful while
creating index. Selection of fields depends on what we are using in our SQL queries.
Example: the following SQL creates a new table called CUSTOMERS and adds five columns:
ID INT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25),
PRIMARY KEY (ID)
);
Now, we can create index on single or multiple columns using the following syntax:

20
CREATE INDEX index_name ON table_name ( column1, column2.....);
To create an INDEX on AGE column, to optimize the search on customers for a particular age,
following is the SQL syntax:
CREATE INDEX idx_age ON CUSTOMERS ( AGE );
DROP an INDEX Constraint: To drop an INDEX constraint, use the following SQL:
ALTER TABLE CUSTOMERS DROP INDEX idx_age;
Data Integrity
The following categories of the data integrity exist with each RDBMS:
 Entity Integrity : There are no duplicate rows in a table.
 Domain Integrity : Enforces valid entries for a given column by restricting the type, the
format, or the range of values.
 Referential Integrity: Rows cannot be deleted which are used by other records.
 User-Defined Integrity: Enforces some specific business rules that do not fall into
entity, domain, or referential integrity.
SQL RDBMS Databases
There are many popular RDBMS available to work with. This tutorial gives a brief overview of
few most popular RDBMS. This would help us to compare their basic features.
MySQL
MySQL is an open source SQL database, which is developed by Swedish company MySQL AB.
MySQL is pronounced "my ess-que-ell," in contrast with SQL, pronounced "sequel."
MySQL is supporting many different platforms including Microsoft Windows, the major Linux
distributions, UNIX, and Mac OS X.
MySQL has free and paid versions, depending on its usage (non-commercial/commercial) and
features. MySQL comes with a very fast, multi-threaded, multi-user, and robust SQL database
server.
History:
 Development of MySQL by Michael Widenius & David Axmark beginning in 1994.
 First internal release on 23 May 1995.
 Windows version was released on 8 January 1998 for Windows 95 and NT.
 Version 3.23: beta from June 2000, production release January 2001.
 Version 4.0: beta from August 2002, production release March 2003 (unions).
 Version 4.01: beta from August 2003, Jyoti adopts MySQL for database tracking.
 Version 4.1: beta from June 2004, production release October 2004.
 Version 5.0: beta from March 2005, production release October 2005.
 Sun Microsystems acquired MySQL AB on 26 February 2008
 Version 5.1: production release 27 November 2008.
Features:

21
 High Performance, High Availability, Scalability and Flexibility Run anything, Robust
Transactional Support, Web and Data Warehouse Strengths, Strong Data Protection,
Comprehensive Application Development, Management Ease, Open Source Freedom and
24 x 7 Support, Lowest Total Cost of Ownership.
MS SQL Server
MS SQL Server is a Relational Database Management System developed by Microsoft Inc. Its
primary query languages are:
 T-SQL.
 ANSISQL.
History:
 1987 - Sybase releases SQL Server for UNIX.
 1988 - Microsoft, Sybase, and Aston-Tate port SQL Server to OS/2.
 1989 - Microsoft, Sybase, and Aston-Tate release SQL Server 1.0 for OS/2.
 1990 - SQL Server 1.1 is released with support for Windows 3.0 clients.
 Aston-Tate drops out of SQL Server development.
 2000 - Microsoft releases SQL Server 2000.
 2001 - Microsoft releases XML for SQL Server Web Release 1 (download).
 2002 - Microsoft releases SQLXML 2.0 (renamed from XML for SQL Server).
 2002 - Microsoft releases SQLXML 3.0.
 2005 - Microsoft releases SQL Server 2005 on November 7th, 2005.
Features:
 High Performance, High Availability, Database mirroring, Database snapshots, Service
Broker, DDL triggers, Ranking functions, Row version-based isolation levels, XML
integration, TRY...CATCH, Database Mail.
ORACLE
It is a very large and multi-user database management system. Oracle is a relational database
management system developed by 'Oracle Corporation'. Oracle works to efficiently manage its
resource, a database of information, among the multiple clients requesting and sending data in
the network.
It is an excellent database server choice for client/server computing. Oracle supports all major
operating systems for both clients and servers, including MSDOS, NetWare, UnixWare, OS/2
and most UNIX flavors.
History: Oracle began in 1977 and celebrating its 32 wonderful years in the industry (from 1977
to 2009).
 1977 - Larry Ellison, Bob Miner and Ed Oates founded Software Development Laboratories
to undertake development work.
 1979 - Version 2.0 of Oracle was released and it became first commercial relational
database and first SQL database. The company changed its name to Relational Software Inc.
(RSI).

22
 1981 - RSI started developing tools for Oracle.
 1982 - RSI was renamed to Oracle Corporation.
 1983 - Oracle released version 3.0, rewritten in C language and ran on multiple platforms.
 1984 - Oracle version 4.0 was released. It contained features like concurrency control -
multi-version read consistency, etc.
 1985 - Oracle version 4.0 was released. It contained features like concurrency control -
multi-version read consistency, etc.
 2007 - Oracle has released Oracle11g. The new version focused on better partitioning, easy
migration, etc.
Features:
 Concurrency, Read Consistency ,Locking Mechanisms ,Portability ,Self-managing database
SQL*Plus ,Scheduler ,Resource Manager ,Data Warehousing ,Materialized views ,Bitmap
indexes ,Table compression ,Parallel Execution ,Analytic SQL ,Data mining,Partitioning,
MS-ACCESS: This is one of the most popular Microsoft products. Microsoft Access is an
entry-level database management software. MS Access database is not only an nexpensive but
also powerful database for small-scale projects. MS Access uses the Jet database engine,which
utilizes a specific SQL language dialect (sometimes referred to as Jet SQL). MS Access comes with the
professional edition of MS Office package. MS Access has easy-to-use intuitive graphical interface.
 1992 - Access version 1.0 was released.
 1993 - Access 1.1 released to improve compatibility with inclusion of the Access Basic
programming language.
 The most significant transition was from Access 97 to Access 2000.
 2007 - Access 2007, a new database format was introduced ACCDB which supports
complex data types such as multi valued and attachment fields.
 Features:
 Users can create tables,queries, forms and reports and connect them together with macros.
 The import and export of data to many formats including Excel, Outlook, ASCII, dBase,Paradox,
FoxPro, SQL Server, Oracle,ODBC,etc.
 There is also the Jet Database format (MDB or ACCDB in Access 2007),which can contain the
application and data in one file. This makes it very convenient to distribute the entire application
to another user, who can run it in disconnected environments.
 Microsoft Access offers parameterized queries. These queries and Access tables can be
referenced from other programs like VB6 and .NET through DAO or ADO.
 The desktop editions of Microsoft SQL Server can be used with Access as an alternative to the Jet
Database Engine.
 Microsoft Access is a file server-based database. Unlike client-server relational database
management systems (RDBMS),Microsoft Access does not implement database triggers, stored
procedures, or transaction logging.

23
SQL Syntax(Quick Reference)
SQL is followed by unique set of rules and guidelines called Syntax. This tutorial gives us a
quick start with SQL by listing all the basic SQL Syntax: All the SQL statements start with any
of the keywords like SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE,
SHOW and all the statements end with a semicolon (;).
Important point to be noted is that SQL is case insensitive, which means SELECT and select
have same meaning in SQL statements, but MySQL makes difference in table names. So if we
are working with MySQL, then we need to give table names as they exist in the database.
SQL SELECT Statement:
SELECT column1, column2....columnN FROM table_name;
SQL DISTINCT Clause:
SELECT DISTINCT column1, column2....columnN FROM table_name;
SQL WHERE Clause:
WHERE CONDITION;
SQL IN Clause:
WHERE column_name IN (val-1, val-2,...val-N);
SQL AND/OR Clause:
WHERE CONDITION-1 {AND|OR} CONDITION-2;
SQL BETWEEN Clause:
WHERE column_name BETWEEN val-1 AND val-2;
SQL LIKE Clause:
WHERE column_name LIKE { PATTERN };
SQL ORDER BY Clause:
WHERE CONDITION ORDER BY column_name {ASC|DESC};
SQL GROUP BY Clause:
WHERE CONDITION GROUP BY column_name;
SQL COUNT Clause:
SELECT COUNT(column_name) FROM table_name
WHERE CONDITION;
SQL HAVING Clause:
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);
SQL CREATE TABLE Statement:

24
CREATE TABLE table_name (
column1 datatype,
column2 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns ));
SQL DROP TABLE Statement:
DROP TABLE table_name;
SQL CREATE INDEX Statement:
CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);
SQL DROP INDEX Statement:
DROP INDEX index_name;
SQL DESC Statement:
DESC table_name;
SQL TRUNCATE TABLE Statement:
TRUNCATE TABLE table_name;
SQL ALTER TABLE Statement:
ALTER TABLE table_name {ADD|DROP|MODIFY} column_name
{data_ype};
SQL ALTER TABLE Statement (Rename):
ALTER TABLE table_name RENAME TO new_table_name;
SQL INSERT INTO Statement:
INSERT INTO table_name( column1, column2....columnN) VALUES ( value1, alue2....valueN);
SQL UPDATE Statement:
UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];
SQL DELETE Statement:
DELETE FROM table_name
WHERE {CONDITION};
SQL CREATE DATABASE Statement:
CREATE DATABASE database_name;
SQL DROP DATABASE Statement:
DROP DATABASE database_name;
SQL USE Statement:
USE DATABASE database_name;
SQL COMMIT Statement:
COMMIT;
SQL ROLLBACK Statement:
ROLLBACK;
SQL Data Types

25
SQL data type is an attribute that specifies type of data of any object. Each column, variable and
expression has related data type in SQL. We would use these data types while creating our
tables. We would choose a particular data type for a table column based on our requirement.
Some data types used in SQL Server are::
Data Types:
i) Character data type
a) Char(size)- used to store character strings values of fixed length.
b) Varchar(size)- used to store character strings values of variable length.
ii) Numeric data type
a) int or interger or smallint- used to store integer numbers of various size.
b) numeric(i,j) or decimal(i,j)- used to store formatted numbers, where i is the
precision, the total number of decimal digits and j is the scale, the no. of digits
after the decimal point.
iii) Date & Time data type- used to store date in YYYY-MM-DD format.
a) datetime
b) smalltime
iv) Raw/Long Raw data types- used to store binary data such as digitized pictures or
image.
SQL Operators
What is an Operator in SQL?
An operator is a reserved word or a character used primarily in an SQL statement's WHERE
clause to perform operation(s), such as comparisons and arithmetic operations. Operators are
used to specify conditions in an SQL statement and to serve as conjunctions for multiple
conditions in a statement.
 Arithmetic operators
 Comparison operators
 Logical operators
 Operators used to negate conditions
SQL Arithmetic Operators: Assume variable a holds 10 and variable b holds 20, then:
Operator Description Example
+ Addition - Adds values on either side of the operator a + b will give 30
- Subtraction - Subtracts right hand operand from left hand
operand
a - b will give -10
* Multiplication - Multiplies values on either side of the
operator
a * b will give 200
/ Division - Divides left hand operand by right hand
operand
b / a will give 2
% Modulus - Divides left hand operand by right hand
operand and returns remainder
b % a will give 0

26
Here are simple examples showing usage of SQL Arithmetic Operators:
SQL> select 10+ 20;
+--------+
| 10+ 20 |
+--------+
| 30 |
+--------+
1 row in set (0.00 sec)
SQL> select 10 * 20;
+---------+
| 10 * 20 |
+---------+
| 200 |
+---------+
SQL> select 10 / 5;
+--------+
| 10 / 5 |
+--------+
| 2.0000 |
+--------+
SQL> select 12 % 5;
+---------+
| 12 % 5 |
+---------+
| 2 |
+---------+
SQL Comparison Operators: Assume variable a holds 10 and variable b holds 20, then:
Operator Description Example
= Checks if the values of two operands are equal or not, if yes
then condition becomes true.
(a = b) is not true.
!= Checks if the values of two operands are equal or not, if values
are not equal then condition becomes true.
(a != b) is true.
<> Checks if the values of two operands are equal or not, if values
are not equal then condition becomes true.
(a <> b) is true.
> Checks if the value of left operand is greater than the value of
right operand, if yes then condition becomes true.
(a > b) is not true.
< Checks if the value of left operand is less than the value of right (a < b) is true.

27
operand, if yes then condition becomes true.
>= Checks if the value of left operand is greater than or equal to
the value of right operand, if yes then condition becomes true.
(a >= b) is not true.
<= Checks if the value of left operand is less than or equal to the
value of right operand, if yes then condition becomes true.
(a <= b) is true.
!< Checks if the value of left operand is not less than the value of
right operand, if yes then condition becomes true.
(a !< b) is false.
!> Checks if the value of left operand is not greater than the value
of right operand, if yes then condition becomes true.
(a !> b) is true.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Here are simple examples showing usage of SQL Comparison Operators:
SQL> SELECT * FROM CUSTOMERS WHERE SALARY > 5000;
+----+----------+-----+---------+----------+
+----+----------+-----+---------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 2000;
+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+

28
SQL> SELECT * FROM CUSTOMERS WHERE SALARY != 2000;
+----+----------+-----+---------+----------+
+----+----------+-----+---------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
SQL> SELECT * FROM CUSTOMERS WHERE SALARY <> 2000;
+----+----------+-----+---------+----------+|
ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
SQL> SELECT * FROM CUSTOMERS WHERE SALARY >= 6500;
+----+----------+-----+---------+----------+
+----+----------+-----+---------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+
SQL Logical Operators:
Here is a list of all the logical operators available in SQL. ALL operators is used to compare a
value to all values in another value set.
Operator Description
AND The AND operator allows the existence of multiple conditions in an
SQL statement's WHERE clause.
ANY The ANY operator is used to compare a value to any applicable value in
the list according to the condition.
BETWEEN The BETWEEN operator is used to search for values that are within a

29
set of values, given the minimum value and the maximum value.
EXISTS The EXISTS operator is used to search for the presence of a row in a
specified table that meets certain criteria.
IN The IN operator is used to compare a value to a list of literal values that
have been specified.
LIKE The LIKE operator is used to compare a value to similar values using
wildcard operators.
NOT The NOT operator reverses the meaning of the logical operator with
which it is used. Eg: NOT EXISTS, NOT BETWEEN, NOT IN, etc.
This is a negate operator.
OR The OR operator is used to combine multiple conditions in an SQL
statement's WHERE clause.
IS NULL The NULL operator is used to compare a value with a NULL value.
UNIQUE The UNIQUE operator searches every row of a specified table for
uniqueness (no duplicates).
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Here are simple examples showing usage of SQL Comparison Operators:
SQL> SELECT * FROM CUSTOMERS WHERE AGE >= 25 AND SALARY >= 6500;
+----+----------+-----+---------+---------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+---------+---------+
SQL> SELECT * FROM CUSTOMERS WHERE AGE >= 25 OR SALARY >= 6500;
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |

30
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
SQL> SELECT * FROM CUSTOMERS WHERE AGE IS NOT NULL;
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
SQL> SELECT * FROM CUSTOMERS WHERE NAME LIKE 'Ko%';
+----+-------+-----+---------+---------+
| 6 | Komal | 22 | MP | 4500.00 |
+----+-------+-----+---------+---------+
SQL> SELECT* FROM CUSTOMERS WHERE AGE IN ( 25, 27 );
+----+----------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+---------+---------+
SQL> SELECT * FROM CUSTOMERS WHERE AGE BETWEEN 25 AND 27;
+----+----------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+---------+---------+
SQL> SELECT AGE FROM CUSTOMERS
WHERE EXISTS (SELECT AGE FROM CUSTOMERS WHERE SALARY > 6500);

31
| AGE |
+-----+
| 32 |
| 25 |
| 23 |
| 25 |
| 27 |
| 22 |
| 24 |
+-----+
SQL> SELECT * FROM CUSTOMERS
WHERE AGE > ALL (SELECT AGE FROM CUSTOMERS WHERE SALARY > 6500);
+----+--------+-----+-----------+---------+
+----+--------+-----+-----------+---------+
SQL> SELECT * FROM CUSTOMERS WHERE AGE > ANY (SELECT AGE FROM
CUSTOMERS WHERE SALARY > 6500);
+----+----------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+-----------+---------+
SQL Expressions
An expression is a combination of one or more values, operators, and SQL functions that
evaluate to a value. SQL EXPRESSIONs are like formulas and they are written in query
language. We can also use them to query the database for specific set of data.
Syntax: Consider the basic syntax of the SELECT statement as follows:
FROM table_name
WHERE [CONDITION|EXPRESSION];
There are different types of SQL expressions, which are mentioned below:
SQL -Boolean Expressions: SQL Boolean Expressions fetch the data on the basis of matching
single value. Following is the syntax:

32
FROM table_name
WHERE SINGLE VALUE MATCHTING EXPRESSION;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+ 7 rows in set (0.00 sec)
Here is simple example showing usage of SQL Boolean Expressions:
SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
+----+-------+-----+---------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+-------+-----+---------+----------+
SQL -Numeric Expression: This expression is used to perform any mathematical operation in
any query. Following is the syntax:
SELECT numerical_expression as OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;
Here numerical_expression is used for mathematical expression or any formula. Following is a
simple examples showing usage of SQL Numeric Expressions:
SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
| 21 |
+----------+
There are several built-in functions like avg(), sum(), count(), etc., to perform what is known
as aggregate data calculations against a table or a specific table column.

33
SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS;
+---------+
| RECORDS |
+---------+
| 7 |
+---------+
SQL -Date Expressions: Date Expressions return current system date and time values:
SQL> SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
Another date expression is as follows:
SQL> SELECT GETDATE();;
+-------------------------+
| GETDATE |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
SQL AND and OR Operators
The SQL AND and OR operators are used to combine multiple conditions to narrow data in an
SQL statement. These two operators are called conjunctive operators. These operators provide a
means to make multiple comparisons with different operators in the same SQL statement.
The AND Operator: The AND operator allows the existence of multiple conditions in an SQL
statement's WHERE clause.
Syntax: The basic syntax of AND operator with WHERE clause is as follows:
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

34
We can combine N number of conditions using AND operator. For an action to be taken by the
SQL statement, whether it be a transaction or query, all conditions separated by the AND must
be TRUE.
Example:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
table where salary is greater than 2000 AND age is less tan 25 years:
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;
+----+-------+----------+
+----+-------+----------+
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+-------+----------+
The OR Operator:
The OR operator is used to combine multiple conditions in an SQL statement's WHERE clause.
Syntax: The basic syntax of OR operator with WHERE clause is as follows:
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]
We can combine N number of conditions using OR operator. For an action to be taken by the
SQL statement, whether it be a transaction or query, only any ONE of the conditions separated
by the OR must be TRUE.
Example:
+----+----------+-----+-----------+----------+

35
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
table where salary is greater than 2000 OR age is less tan 25 years:
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS WHERE SALARY > 2000
OR age < 25;
+----+----------+----------+
+----+----------+----------+
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
SQL LIKE Clause: The SQL LIKE clause is used to compare a value to similar values using
wildcard operators. There are two wildcards used in conjunction with the LIKE operator:
 The percent sign (%)
 The underscore (_)
The percent sign represents zero, one, or multiple characters. The underscore represents a single
number or character. The symbols can be used in combinations.
Syntax:
The basic syntax of % and _ is as follows:
SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or
WHERE column LIKE '%XXXX%'
or
WHERE column LIKE 'XXXX_'
or

36
WHERE column LIKE '_XXXX'
or
WHERE column LIKE '_XXXX_'
We can combine N number of conditions using AND or OR operators. Here, XXXX could be
any numeric or string value.
Example:
Here are number of examples showing WHERE part having different LIKE clause with '%' and
'_' operators:
Statement Description
WHERE SALARY LIKE '200%' Finds any values that start with 200
WHERE SALARY LIKE '%200%' Finds any values that have 200 in any
position
WHERE SALARY LIKE '_00%' Finds any values that have 00 in the
second and third positions
WHERE SALARY LIKE '2_%_%' Finds any values that start with 2 and are
at least 3 characters in length
WHERE SALARY LIKE '%2' Finds any values that end with 2
WHERE SALARY LIKE '_2%3' Finds any values that have a 2 in the
second position and end with a 3
WHERE SALARY LIKE '2___3' Finds any values in a five-digit number
that start with 2 and end with 3
SQL ORDER BY Clause : The SQL ORDER BY clause is used to sort the data in ascending or
descending order, based on one or more columns. Some database sorts query results in ascending
order by default.
Syntax:
The basic syntax of ORDER BY clause is as follows:
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
We can use more than one column in the ORDER BY clause. Make sure whatever column we
are using to sort, that column should be in column-list.
Example:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |

37
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is an example, which would sort the result in ascending order by NAME and
SALARY:
SQL> SELECT * FROM CUSTOMERS ORDER BY NAME, SALARY;
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is an example, which would sort the result in descending order by NAME:
SQL> SELECT * FROM CUSTOMERS ORDER BY NAME DESC;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
SQL Group By: The SQL GROUP BY clause is used in collaboration with the SELECT
statement to arrange identical data into groups. The GROUP BY clause follows the WHERE
clause in a SELECT statement and precedes the ORDER BY clause.
Syntax:
The basic syntax of GROUP BY clause is given below. The GROUP BY clause must follow the
conditions in the WHERE clause and must precede the ORDER BY clause if one is used.
SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2
Example:
+----+----------+-----+-----------+----------+

38
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
If we want to know the total amount of salary on each customer, then GROUP BY query would
be as follows:
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS GROUP BY NAME;
+----------+-------------+
| NAME | SUM(SALARY) |
+----------+-------------+
| Chaitali | 6500.00 |
| Hardik | 8500.00 |
| kaushik | 2000.00 |
| Khilan | 1500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 2000.00 |
+----------+-------------+
Now, let us have following table where CUSTOMERS table has the following records with
duplicate names:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Now again, if we want to know the total amount of salary on each customer, then GROUP BY
query would be as follows:
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS GROUP BY NAME;
+---------+-------------+
| NAME | SUM(SALARY) |
+---------+-------------+
| Hardik | 8500.00 |

39
| kaushik | 8500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 3500.00 |
+---------+-------------+
SQL Distinct Keyword
The SQL DISTINCT keyword is used in conjunction with SELECT statement to eliminate all
the duplicate records and fetching only unique records.
There may be a situation when we have multiple duplicate records in a table. While fetching
such records, it makes more sense to fetch only unique records instead of fetching duplicate
records.
Syntax:
The basic syntax of DISTINCT keyword to eliminate duplicate records is as follows:
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]
Example:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
First, let us see how the following SELECT query returns duplicate salary records:
SQL> SELECT SALARY FROM CUSTOMERS ORDER BY SALARY;
This would produce the following result where salary 2000 is coming twice which is a duplicate
record from the original table.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
Now, let us use DISTINCT keyword with the above SELECT query and see the result:

40
SQL> SELECT DISTINCT SALARY FROM CUSTOMERS ORDER BY SALARY;
This would produce the following result where we do not have any duplicate entry:
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
SQL SORTING Results
The SQL ORDER BY clause is used to sort the data in ascending or descending order, based on
one or more columns. Some databases sort query results in ascending order by default.
Syntax:
The basic syntax of ORDER BY clause which would be used to sort result in ascending or
descending order is as follows:
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
We can use more than one column in the ORDER BY clause. Make sure whatever column we
are using to sort, that column should be in column-list.
Example:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is an example, which would sort the result in ascending order by NAME and
SALARY:
SQL> SELECT * FROM CUSTOMERS ORDER BY NAME, SALARY;

41
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is an example, which would sort the result in descending order by NAME:
SQL> SELECT * FROM CUSTOMERS ORDER BY NAME DESC;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+
SQL Joins
The SQL Joins clause is used to combine records from two or more tables in a database. A JOIN
is a means for combining fields from two tables by using values common to each.
Consider the following two tables,
(a) CUSTOMERS table is as follows:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
(b) Another table is ORDERS as follows:
+-----+---------------------+-------------+--------+
|OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |

42
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
Now, let us join these two tables in our SELECT statement as follows:
SQL> SELECT ID, NAME, AGE, AMOUNT
FROM CUSTOMERS, ORDERS
WHERE CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+
Here, it is noticeable that the join is performed in the WHERE clause. Several operators can be
used to join tables, such as =, <, >, <>, <=, >=, !=, BETWEEN, LIKE, and NOT; they can all be
used to join tables. However, the most common operator is the equal symbol.
SQL Join Types:
There are different types of joins available in SQL:
 INNER JOIN: returns rows when there is a match in both tables.
 LEFT JOIN: returns all rows from the left table, even if there are no matches in the right
table.
 RIGHT JOIN: returns all rows from the right table, even if there are no matches in the
left table.
 FULL JOIN: returns rows when there is a match in one of the tables.
 SELF JOIN: is used to join a table to itself as if the table were two tables, temporarily
renaming at least one table in the SQL statement.
 CARTESIAN JOIN: returns the Cartesian product of the sets of records from the two or
more joined tables.
INNER JOIN
The most frequently used and important of the joins is the INNER JOIN. They are also referred
to as an EQUIJOIN. The INNER JOIN creates a new result table by combining column values of
two tables (table1 and table2) based upon the join-predicate. The query compares each row of
table1 with each row of table2 to find all pairs of rows which satisfy the join-predicate. When the
join-predicate is satisfied, column values for each matched pair of rows of A and B are combined
into a result row.
Syntax:
The basic syntax of INNER JOIN is as follows:
SELECT table1.column1, table2.column2...
FROM table1

43
INNER JOIN table2
ON table1.common_filed = table2.common_field;
Now, let us join these two tables using INNER JOIN as follows:
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
+----+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+----+----------+--------+---------------------+
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+
LEFT JOIN
The SQL LEFT JOIN returns all rows from the left table, even if there are no matches in the
right table. This means that if the ON clause matches 0 (zero) records in right table, the join will
still return a row in the result, but with NULL in each column from right table.
This means that a left join returns all the values from the left table, plus matched values from the
right table or NULL in case of no matching join predicate.
Syntax: The basic syntax of LEFT JOIN is as follows:
FROM table1
LEFT JOIN table2
Here given condition could be any given expression based on our requirement.
Example:
Now, let us join these two tables using LEFT JOIN as follows:
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS LEFT JOIN
ORDERS ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
+----+----------+--------+---------------------+
+----+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
+----+----------+--------+---------------------+

44
RIGHT JOIN
The SQL RIGHT JOIN returns all rows from the right table, even if there are no matches in the
left table. This means that if the ON clause matches 0 (zero) records in left table, the join will
still return a row in the result, but with NULL in each column from left table.
This means that a right join returns all the values from the right table, plus matched values from
the left table or NULL in case of no matching join predicate.
Syntax: The basic syntax of RIGHT JOIN is as follows:
FROM table1
RIGHT JOIN table2
Now, let us join these two tables using RIGHT JOIN as follows:
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS RIGHT JOIN
+------+----------+--------+---------------------+
+------+----------+--------+---------------------+
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+
FULL JOIN
The SQL FULL JOIN combines the results of both left and right outer joins. The joined table
will contain all records from both tables, and fill in NULLs for missing matches on either side.
Syntax: The basic syntax of FULL JOIN is as follows:
FROM table1
FULL JOIN table2
Now, let us join these two tables using FULL JOIN as follows:
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS FULL JOIN
+------+----------+--------+---------------------+
+------+----------+--------+---------------------+
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |

45
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+
If our Database does not support FULL JOIN like MySQL does not support FULL JOIN, then
we can use UNION ALL clause to combine two JOINS as follows:
SQL> SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
SELF JOIN
The SQL SELF JOIN is used to join a table to itself as if the table were two tables, temporarily
renaming at least one table in the SQL statement.
Syntax:
The basic syntax of SELF JOIN is as follows:
SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_filed = b.common_field;
Here, WHERE clause could be any given expression based on our requirement.
Now, let us join this table using SELF JOIN as follows:
SQL> SELECT a.ID, b.NAME, a.SALARY FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY < b.SALARY;
+----+----------+---------+
+----+----------+---------+
| 2 | Ramesh | 1500.00 |
| 2 | kaushik | 1500.00 |
| 1 | Chaitali | 2000.00 |
| 2 | Chaitali | 1500.00 |
| 3 | Chaitali | 2000.00 |
| 6 | Chaitali | 4500.00 |
| 1 | Hardik | 2000.00 |
| 2 | Hardik | 1500.00 |
| 3 | Hardik | 2000.00 |

46
| 4 | Hardik | 6500.00 |
| 6 | Hardik | 4500.00 |
| 1 | Komal | 2000.00 |
| 2 | Komal | 1500.00 |
| 3 | Komal | 2000.00 |
| 1 | Muffy | 2000.00 |
| 2 | Muffy | 1500.00 |
| 3 | Muffy | 2000.00 |
| 4 | Muffy | 6500.00 |
| 5 | Muffy | 8500.00 |
| 6 | Muffy | 4500.00 |
+----+----------+---------+
CARTESIAN JOIN
The CARTESIAN JOIN or CROSS JOIN returns the cartesian product of the sets of records
from the two or more joined tables. Thus, it equates to an inner join where the join-condition
always evaluates to True or where the join-condition is absent from the statement.
Syntax:
The basic syntax of INNER JOIN is as follows:
FROM table1, table2 [, table3 ]
Now, let us join these two tables using INNER JOIN as follows:
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS, ORDERS;
+----+----------+--------+---------------------+
+----+----------+--------+---------------------+
| 1 | Ramesh | 3000 | 2009-10-08 00:00:00 |
| 1 | Ramesh | 1500 | 2009-10-08 00:00:00 |
| 1 | Ramesh | 1560 | 2009-11-20 00:00:00 |
| 1 | Ramesh | 2060 | 2008-05-20 00:00:00 |
| 2 | Khilan | 3000 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 2 | Khilan | 2060 | 2008-05-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 2060 | 2008-05-20 00:00:00 |
| 4 | Chaitali | 3000 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | 3000 | 2009-10-08 00:00:00 |
| 5 | Hardik | 1500 | 2009-10-08 00:00:00 |

47
| 5 | Hardik | 1560 | 2009-11-20 00:00:00 |
| 5 | Hardik | 2060 | 2008-05-20 00:00:00 |
| 6 | Komal | 3000 | 2009-10-08 00:00:00 |
| 6 | Komal | 1500 | 2009-10-08 00:00:00 |
| 6 | Komal | 1560 | 2009-11-20 00:00:00 |
| 6 | Komal | 2060 | 2008-05-20 00:00:00 |
| 7 | Muffy | 3000 | 2009-10-08 00:00:00 |
| 7 | Muffy | 1500 | 2009-10-08 00:00:00 |
| 7 | Muffy | 1560 | 2009-11-20 00:00:00 |
| 7 | Muffy | 2060 | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+
SQL Unions Clause
The SQL UNION clause/operator is used to combine the results of two or more SELECT
statements without returning any duplicate rows. To use UNION, each SELECT must have the
same number of columns selected, the same number of column expressions, the same data type,
and have them in the same order, but they do not have to be the same length.
Syntax:
The basic syntax of UNION is as follows:
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION
[WHERE condition]
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS
UNION
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS
+------+----------+--------+---------------------+
+------+----------+--------+---------------------+
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |

48
+------+----------+--------+---------------------+
The UNION ALL Clause:
The UNION ALL operator is used to combine the results of two SELECT statements including
duplicate rows. The same rules that apply to UNION apply to the UNION ALL operator.
Syntax:
The basic syntax of UNION ALL is as follows:
[WHERE condition]
UNION ALL
[WHERE condition]
Example:
SQL> SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
+------+----------+--------+---------------------+
+------+----------+--------+---------------------+
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+
There are two other clauses (i.e., operators), which are very similar to UNION clause:
 SQL INTERSECT Clause: is used to combine two SELECT statements, but returns
rows only from the first SELECT statement that are identical to a row in the second
SELECT statement.

49
 SQL EXCEPT Clause : combines two SELECT statements and returns rows from
the first SELECT statement that are not returned by the second SELECT
statement.
INTERSECT Clause
The SQL INTERSECT clause/operator is used to combine two SELECT statements, but returns
rows only from the first SELECT statement that are identical to a row in the second SELECT
statement. This means INTERSECT returns only common rows returned by the two SELECT
statements.
Just as with the UNION operator, the same rules apply when using the INTERSECT operator.
MySQL does not support INTERSECT operator
Syntax:
The basic syntax of INTERSECT is as follows:
[WHERE condition]
INTERSECT
[WHERE condition]
Example:
Consider the following two tables, (a) CUSTOMERS table is as follows:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
FROM CUSTOMERS

50
LEFT JOIN ORDERS
INTERSECT
FROM CUSTOMERS
RIGHT JOIN ORDERS
+------+---------+--------+---------------------+
+------+---------+--------+---------------------+
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Ramesh | 1560 | 2009-11-20 00:00:00 |
| 4 | kaushik | 2060 | 2008-05-20 00:00:00 |
+------+---------+--------+---------------------+
EXCEPT Clause
The SQL EXCEPT clause/operator is used to combine two SELECT statements and returns
rows from the first SELECT statement that are not returned by the second SELECT statement.
This means EXCEPT returns only rows, which are not available in second SELECT statement.
Just as with the UNION operator, the same rules apply when using the EXCEPT operator.
MySQL does not support EXCEPT operator.
Syntax:
The basic syntax of EXCEPT is as follows:
[WHERE condition]
EXCEPT
[WHERE condition]
Example:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

51
+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
FROM CUSTOMERS
LEFT JOIN ORDERS
EXCEPT
FROM CUSTOMERS
RIGHT JOIN ORDERS
+----+---------+--------+---------------------+
+----+---------+--------+---------------------+
+----+---------+--------+---------------------+
SQL NULL Values
The SQL NULL is the term used to represent a missing value. A NULL value in a table is a
value in a field that appears to be blank.
A field with a NULL value is a field with no value. It is very important to understand that a
NULL value is different than a zero value or a field that contains spaces.
Syntax:
The basic syntax of NULL while creating a table:
SQL> CREATE TABLE CUSTOMERS(
ID INT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25) ,
PRIMARY KEY (ID)
);
Here, NOT NULL signifies that column should always accept an explicit value of the given data
type. There are two columns where we did not use NOT NULL, which means these columns
could be NULL.
A field with a NULL value is one that has been left blank during record creation.

52
Example:
The NULL value can cause problems when selecting data, however, because when comparing an
unknown value to any other value, the result is always unknown and not included in the final
results.
We must use the IS NULL or IS NOT NULL operators in order to check for a NULL value.
Consider the following table, CUSTOMERS having the following records:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | |
| 7 | Muffy | 24 | Indore | |
+----+----------+-----+-----------+----------+
Now, following is the usage of IS NOT NULL operator:
SQL> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
WHERE SALARY IS NOT NULL;
+----+----------+-----+-----------+----------+
1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
+----+----------+-----+-----------+----------+
Now, following is the usage of IS NULL operator:
SQL> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
WHERE SALARY IS NULL;
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 6 | Komal | 22 | MP | |
| 7 | Muffy | 24 | Indore | |
+----+----------+-----+-----------+----------+
SQL Alias Syntax
We can rename a table or a column temporarily by giving another name known as alias. The use
of table aliases means to rename a table in a particular SQL statement. The renaming is a

53
temporary change and the actual table name does not change in the database. The column aliases
are used to rename a table's columns for the purpose of a particular SQL query.
Syntax: The basic syntax of table alias is as follows:
SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];
The basic syntax of column alias is as follows:
SELECT column_name AS alias_name
FROM table_name
WHERE [condition];
Example:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Now, following is the usage of table alias:
SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT FROM CUSTOMERS AS C,
ORDERS AS O WHERE C.ID = O.CUSTOMER_ID;
+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |

54
+----+----------+-----+--------+
Following is the usage of column alias:
SQL> SELECT ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME FROM
CUSTOMERS WHERE SALARY IS NOT NULL;
+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
| 1 | Ramesh |
| 2 | Khilan |
| 3 | kaushik |
| 4 | Chaitali |
| 5 | Hardik |
| 6 | Komal |
| 7 | Muffy |
+-------------+---------------+
SQL -Using Views
A view is nothing more than a SQL statement that is stored in the database with an associated
name. A view is actually a composition of a table in the form of a predefined SQL query.
A view can contain all rows of a table or select rows from a table. A view can be created from
one or many tables which depends on the written SQL query to create a view.
Views, which are kind of virtual tables, allow users to do the following:
 Structure data in a way that users or classes of users find natural or intuitive.
 Restrict access to the data such that a user can see and (sometimes) modify exactly what they
need and no more.
 Summarize data from various tables which can be used to generate reports.
Creating Views: Database views are created using the CREATE VIEW statement. Views can
be created from a single table, multiple tables, or another view. To create a view, a user must
have the appropriate system privilege according to the specific implementation.
The basic CREATE VIEW syntax is as follows:
CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];
We can include multiple tables in our SELECT statement in very similar way as we use them in
normal SQL SELECT query.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+

55
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Now, following is the example to create a view from CUSTOMERS table. This view would be
used to have customer name and age from CUSTOMERS table:
SQL > CREATE VIEW CUSTOMERS_VIEW AS SELECT name, age FROM
CUSTOMERS;
Now, we can query CUSTOMERS_VIEW in similar way as we query an actual table. Following
is the example:
SQL > SELECT * FROM CUSTOMERS_VIEW;
+----------+-----+
| name | age |
+----------+-----+
| Ramesh | 32 |
| Khilan | 25 |
| kaushik | 23 |
| Chaitali | 25 |
| Hardik | 27 |
| Komal | 22 |
| Muffy | 24 |
+----------+-----+
The WITH CHECK OPTION:
The WITH CHECK OPTION is a CREATE VIEW statement option. The purpose of the WITH
CHECK OPTION is to ensure that all UPDATE and INSERTs satisfy the condition(s) in the
view definition. If they do not satisfy the condition(s), the UPDATE or INSERT returns an error.
The following is an example of creating same view CUSTOMERS_VIEW with the WITH
CHECK OPTION:
CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;
The WITH CHECK OPTION in this case should deny the entry of any NULL values in the
view's AGE column, because the view is defined by data that does not have a NULL value in the
AGE column.

56
Updating a View: A view can be updated under certain conditions:
 The SELECT clause may not contain the keyword DISTINCT.
 The SELECT clause may not contain summary functions.
 The SELECT clause may not contain set functions.
 The SELECT clause may not contain set operators.
 The SELECT clause may not contain an ORDER BY clause.
 The FROM clause may not contain multiple tables.
 The WHERE clause may not contain subqueries.
 The query may not contain GROUP BY or HAVING.
 Calculated columns may not be updated.
 All NOT NULL columns from the base table must be included in the view in order for the
INSERT query to function.
So if a view satisfies all the above mentioned rules then we can update a view. Following is an
example to update the age of Ramesh:
SQL > UPDATE CUSTOMERS_VIEW SET AGE = 35 WHERE name='Ramesh';
This would ultimately update the base table CUSTOMERS and same would reflect in the view
itself. Now, try to query base table, and SELECT statement would produce the following result:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Inserting Rows into a View: Rows of data can be inserted into a view. The same rules that
apply to the UPDATE command also apply to the INSERT command. Here, we cannot insert
rows in CUSTOMERS_VIEW because we have not included all the NOT NULL columns in this
view, otherwise we can insert rows in a view in similar way as we insert them in a table.
Deleting Rows into a View: Rows of data can be deleted from a view. The same rules that apply
to the UPDATE and INSERT commands apply to the DELETE command. Following is an
example to delete a record having AGE= 22.
SQL > DELETE FROM CUSTOMERS_VIEW WHERE age = 22;
This would ultimately delete a row from the base table CUSTOMERS and same would reflect in
the view itself. Now, try to query base table, and SELECT statement would produce the
following result:

57
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Dropping Views: Obviously, where we have a view, we need a way to drop the view if it is no
longer needed. The syntax is very simple as given below:
DROP VIEW view_name;
Following is an example to drop CUSTOMERS_VIEW from CUSTOMERS table:
SQL > DROP VIEW CUSTOMERS_VIEW;
SQL HAVING CLAUSE: The HAVING clause enables we to specify conditions that filter
which group results appear in the final results. The WHERE clause places conditions on the
selected columns, whereas the HAVING clause places conditions on groups created by the
GROUP BY clause.
Syntax: The following is the position of the HAVING clause in a query:
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
The HAVING clause must follow the GROUP BY clause in a query and must also precede the
ORDER BY clause if used. The following is the syntax of the SELECT statement, including the
HAVING clause:
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |

58
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is the example, which would display record for which similar age count would be
more than or equal to 2:
SQL > SELECT * FROM CUSTOMERS GROUP BY age HAVING COUNT(age) >= 2;
+----+--------+-----+---------+---------+
+----+--------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |

SQL Tutorial for BCA-2

More Related Content

What's hot (20)

Similar to SQL Tutorial for BCA-2 (20)

More from Raj vardhan (20)

Recently uploaded (20)

SQL Tutorial for BCA-2