Module 3

MODULE 3
1. Introduction to SQL
SQL (Structured Query Language) is a database sublanguage for querying and
modifying relational databases. It was developed by IBM Research in the mid 70's
and standardized by ANSI in 1986. In the relational model, data is stored in
structures called relations or tables. Each table has one or more attributes or
columns that describe the table. In relational databases, the table is the fundamental
building block of a database application.
SQL language consists of two categories of statements:
• Data Definition Language (DDL) used to create, alter and drop schema
objects such as tables and indexes, and
• Data Manipulation Language (DML) used to manipulate the data within those
schema objects.
Oracle's SQL*Plus is a command line tool that allows a user to type SQL statements to be
executed directly against an Oracle database. SQL*Plus commands allow a user to do the
following activities:
• Enter, edit, store, retrieve, and run SQL statements
• List the column definitions for any table
• Format, perform calculations on, store, and print query results in the form of
reports
• Access and copy data between SQL databases
Oracle Database Objects
 TABLESPACE - A Tablespace is the physical space (in fact, a physical data file
in the hard disk) where tables are stored.
 TABLE - Consists of ROWS of data separated into different COLUMNS.
 VIEW – A virtual relation for specific user group.
 INDEX – A search index created for a table to improve query performance.
 TRIGGER – A sub program stored in the database that gets executed
automatically on a data manipulation event on a table.
 SEQUENCE – A database object for creating sequential numbers for use as a
primary key, for example.
 PROCEDURE / FUNCTION – A sub program stored in the database for a
specific application use.

CS208 Principles of Database Design Module 3
 PACKAGE – A collection of stored sub programs (procedures or functions) in
the database.
 USER – Stores the user name of the current session.
 SYSDATE – Stores the current system date and time.
Data Types in SQL Statements
a) CHAR(n) - Character string, fixed length n
b) VARCHAR2(n) - Variable length character string, maximum length n.
c) NUMBER (p) - Integer numbers with precision p.
d) BOOLEAN - Boolean variable used to store TRUE, FALSE, NULL
e) DATE - Stores year, month, day, hour, minute and second values
f) BLOB – Binary Large OBject (the data type in Oracle for storing binary files
like executables, images etc.)
1.1DDL Statements
The DDL statements are used to create and alter the database objects. Common
DDL statements are:
o CREATE TABLE
o ALTER TABLE
o CREATE INDEX
o DROP TABLE
o DROP INDEX
o CREATE USER
o ALTER USER
o CREATE SEQUENCE
o CREATE TRIGGER
o CREATE PROCEDURE
o CREATE PACKAGE
1) CREATE TABLE
The CREATE TABLE Statement creates a new database table.
Syntax:
CREATE TABLE <table name> (column1 data type (size), column2 data
type (size), column3 data type (size),………);
2

Constraints
Constraint specifications add additional restrictions on the contents of the table. They
are automatically enforced by the DBMS.
a) Primary Key: Specifies the columns that uniquely identify a row in a table.
One or more columns could be part of a primary key.
Syntax:
CREATE TABLE <table name> (column1 data type (size) PRIMARY KEY,
column2 data type (size), column3 data type (size),………);
b) NOT NULL: Specifies that the column can't be set to null. Normally, primary
key columns are declared as NOT NULL.
Syntax:
CREATE TABLE <table name> (column1 data type (size) NOT NULL,
column2 data type (size), column3 data type (size),………);
c) UNIQUE: Specifies that this column has a unique value or null for all rows of
the table.
Syntax:
CREATE TABLE <table name> (column1 data type (size) UNIQUE, column2
data type (size), column3 data type (size),………);
d) Foreign Key: Specifies the set of columns in a table that is used to establish
the relationship with another table in the database.
Syntax:
FOREIGN KEY (column-list) REFERENCES referenced-table (column-
list)
e) CHECK: specifies a user defined constraint, known as a check condition. The
CHECK specifier is followed by a condition enclosed in parentheses.
Syntax:
CREATE Table <table name> (column1 data type (size) CHECK
(Condition), column2 data type (size), column3 data type (size),………);
2) ALTER TABLE
The ALTER TABLE statement is used to change the table definition.
• To add new column
ALTER TABLE <table name> ADD column name datatype (size);
• To add Primary key
ALTER TABLE <table name> ADD Column name PRIMARY KEY;
3

• To add Foreign key
ALTER TABLE <table name> ADD CONSTRAINT <constraint name> FOREIGN
KEY (column name) REFERENCES <table name> (column name);
• To remove a Foreign key constraint
ALTER TABLE <table name> DROP CONSTRAINT <constraint name>
• To rename a table
ALTER TABLE <table name> RENAME TO <new table name>
3) CREATE INDEX
The CREATE INDEX statement allows the creation of an index for an already
existing relation or table.
Syntax:
CREATE [unique] Index <name of index>
On <existing table name> (column name [ascending or descending]
[,column name[asc or desc]) [cluster]
4) DROP TABLE
The DROP TABLE statement removes a previously created table and its
description from the catalog.
Syntax:
DROP TABLE <table-name>
5) DROP INDEX
The DROP INDEX statement removes a previously created index from the
database.
Syntax:
DROP INDEX <index-name>
6) CREATE USER
The CREATE USER statement creates a new database user.
Syntax:
CREATE USER <user name> IDENTIFIED BY <password>
7) ALTER USER
The ALTER USER statement is used to change the password of a database user.
Syntax:
4

ALTER USER <user name> IDENTIFIED BY <new password>
8) CREATE SEQUENCE
The CREATE SEQUENCE statement is used to create a sequence to be used in
DML statements.
Syntax:
CREATE SEQUENCE <sequence name>
START WITH <start sequence number>
MAXVALUE <maximum value of sequence number>
INCREMENT BY <increment value>
NOCYCLE;
1.2 DML Statements
The DML statements are used to manipulate (store and maintain) the data in
database tables. Common DML statements are:
o INSERT
o UPDATE
o DELETE
o SELECT
DML statements use arithmetic and logical operators. Arithmetic and Logical
operators used in DML statements are given below:
Operators in SQL
• Arithmetic operators
+,-,*,/
• Logical operators
=,!= or <>,>,>=,<,<=
• Relational Operators
AND, OR, NOT
• Other Operators
a) LIKE - The LIKE operator implements a pattern match comparison, that is, it
matches a string value against a pattern string containing wild-card characters.
The wild-card characters for LIKE are percent -- '%' and underscore -- '_'.
Underscore matches any single character. Percent matches zero or more
characters.
Example: SELECT * FROM <table name> WHERE <column name> LIKE ‘abc%’
5

b) NOT LIKE - It does not matches a string value against a pattern string
containing wild-card characters.
Example: SELECT * FROM <table name> WHERE <column name> NOT LIKE
'abc%'
c) BETWEEN - The BETWEEN operator implements a range comparison, that is,
it tests whether a value is between two other values.
Example: SELECT * FROM <table name> WHERE qty BETWEEN 50 and 500
d) NOT BETWEEN- It tests whether a value is not between two other values.
Example: SELECT * FROM <table name> WHERE qty NOT BETWEEN 50 and
500
e) IN - The IN operator implements comparison to a list of values, that is, it tests
whether a value matches any value in a list of values
Example: SELECT * FROM <table name> WHERE city IN ('Rome','Paris')
f) NOT IN - It tests whether a value does not matches any value in a list of
values
Example: SELECT * FROM <table name> WHERE city NOT IN ('Rome','Paris')
1. lNSERT
Syntax:
INSERT INTO <table name> VALUES (value-1, value-2…….)
Examples:
 INSERT statement with direct values
INSERT INTO EMPLOYEE (EMPLOYEE_ID, FIRST_NAME, DATE_OF_BIRTH,
SEX,SALARY)
VALUES (1090,’Anitha’,’10-OCT-1980’,’F’,5000)
 INSERT statement with values from another or same table rows
INSERT INTO EMPLOYEE (EMPLOYEE_ID, FIRST_NAME, DATE_OF_BIRTH,
SEX, SALARY)
SELECT 1091, FIRST_NAME, DATE_OF_BIRTH, SEX, SALARY FROM EMPLOYEE
WHERE EMPLOYEE_ID = 1090
2. UPDATE
6

Updating allows us to change some values in a tuple without necessarily changing
all. where clause of update statement may contain any construct legal in a
where clause of a select statement (including nesting). A nested select within
an update may reference the relation that is being updated. As before, all tuples
in the relation are first tested to see whether they should be updated, and the
updates are carried out afterwards.
Example: Update the date of birth of employee 1090 to 15-Oct-1979.
UPDATE EMPLOYEE
SET DATE_OF_BIRTH = ’15-OCT-1979’
Note: WHERE clause can take different forms as listed in SELECT… above,
including SUB QUERY.
3. DELETE
• Delete Specific rows
DELETE FROM <table name> [WHERE predicate]
• Delete all rows
DELETE * FROM <table name>
Example: Delete the record of the employee with employee id 1091.
DELETE FROM EMPLOYEE WHERE EMPLOYEE_ID = 1091
Note: WHERE clause can take different forms as listed in SELECT… above,
including SUB QUERY.
4. SELECT
The SQL SELECT statement queries data from tables in the database. The statement
begins with the SELECT keyword. The basic SELECT statement has 3 clauses:
• SELECT - specifies the table columns retrieved
• FROM - specifies the tables to be accessed
• WHERE - specifies which rows in the FROM tables to use
The WHERE clause could be followed by other clauses as listed below:
ORDER BY Clause
This clause is for retrieving rows in the sorted order.
7

Example: SELECT a from <t> where a LIKE ‘s%’ ORDER BY a;
Group by Clause
This clause group rows based on distinct values that exist for specified columns.
Having Clause
This is used in conjunction with Group By clause. Filter the groups created by the
group by clause.
Example: Write a SQL statement to get the list of departments having average salary
less than the average salary of the company. Include Department ID and Average
Salary of Dept. in the list. Exclude departments with less than 3 employees and
order the list in the descending order of the department average salary.
SELECT DEPARTMENT_ID, AVG(SALARY) FROM EMPLOYEE
GROUP BY DEPARTMENT_ID
HAVING (AVG(SALARY) < (SELECT AVG(SALARY) FROM EMPLOYEE) AND COUNT(*)
>= 3)
ORDER BY 2 DESC
Syntax of SELECT Statements:
SELECT <field names> FROM <table name> WHERE (condition);
To select all rows use the following syntax
SELECT * FROM <table name>
To select unique rows from the table
SELECT DISTINCT select-list
DISTINCT specifies that duplicate rows are discarded.
Examples:
 Statement to return all columns and rows from EMPLOYEE table
SELECT * FROM EMPLOYEE
 Statement to return EMPLOYEE_ID and LAST_NAME columns from EMPLOYEE
table
SELECT EMPLOYEE_ID, LAST_NAME FROM EMPLOYEE
 Statement to get only distinct employee details
8

SELECT DISTINCT FIRST_NAME, LAST_NAME, DATE_OF_BIRTH FROM
EMPLOYEE
 Statement to get details of employee with employee id = 1023
SELECT FIRST_NAME, LAST_NAME, DATE_OF_BIRTH FROM EMPLOYEE
 Statement to get id and last name of all employees in department 1
SELECT EMPLOYEE_ID, LAST_NAME FROM EMPLOYEE WHERE
DEPARTMENT_ID = 1
 Statement to get details of all employees whose first name start with letter A
SELECT FIRST_NAME, LAST_NAME, DATE_OF_BIRTH FROM EMPLOYEE
WHERE FIRST_NAME LIKE ‘A%’
 Statement to get details of all employees with employee ids between 1030
and 1050
SELECT EMPLOYEE_ID, LAST_NAME FROM EMPLOYEE WHERE EMPLOYEE_ID
BETWEEN 1030 AND 1050
 Statement to get details of all employees with employee id greater than 1040
SELECT EMPLOYEE_ID, LAST_NAME FROM EMPLOYEE WHERE EMPLOYEE_ID
> 1040
 Statement to get the total number of employees
SELECT COUNT (*) FROM EMPLOYEE
 Statement to get the number of employees in dept. 1
SELECT COUNT (EMPLOYEE_ID) FROM EMPLOYEE
WHERE DEPARTMENT_ID = 1
 Statement to get the lowest (first) employee number
SELECT MIN(EMPLOYEE_ID) FROM EMPLOYEE
 Statement to get the highest (last) employee number
SELECT MAX(EMPLOYEE_ID) FROM EMPLOYEE
 SUB QUERY
 Statement to get details of employees belonging to department 'ACCOUNTS‘
SELECT EMPLOYEE_ID, LAST_NAME FROM EMPLOYEE WHERE
DEPARTMENT_ID = (SELECT DEPARTMENT_ID FROM DEPARTMENT WHERE
DEPARTMENT_NAME = ‘ACCOUNTS’)
 Statement to get details of employees belonging to departments whose
manager is ANIL KUMAR
SELECT EMPLOYEE_ID, LAST_NAME
9

FROM EMPLOYEE WHERE DEPARTMENT_ID IN (SELECT DEPARTMENT_ID
FROM DEPARTMENT WHERE DEPARTMENT_MANAGER = ‘ANIL KUMAR’)
 Statement to get the list of employees earning more than 20000 if atleast one
employee gets less than 15000. This is called existence test.
SELECT EMPLOYEE_ID, LAST_NAME, SALARY
FROM EMPLOYEE WHERE SALARY > 20000 AND
EXISTS (SELECT * FROM EMPLOYEE WHERE SALARY < 15000)
 Statement to get the list of employees sorted in ascending order of their last
names.
SELECT EMPLOYEE_ID, LAST_NAME FROM EMPLOYEE ORDER BY LAST_NAME
 Statement to get the list of employees sorted in the descending order of their
salary
SELECT EMPLOYEE_ID, LAST_NAME, SALARY FROM EMPLOYEE
ORDER BY SALARY DESC
 Statement to get the list of employees sorted in the ascending order of their
salary
SELECT EMPLOYEE_ID, LAST_NAME, SALARY FROM EMPLOYEE
ORDER BY 3 ASC
 Statement to get the minimum, maximum, average, sum and number of
employees of departments 1 to 3 (these are called group functions)
SELECT DEPARTMENT_ID, MIN(SALARY), MAX(SALARY),
AVG(SALARY), SUM(SALARY), COUNT(*)
FROM EMPLOYEE WHERE DEPARTMENT_ID BETWEEN 1 AND 3
GROUP BY DEPARTMENT_ID
ORDER BY DEPARTMENT_ID
 Statement to get the minimum and maximum salary of departments with
difference of min and max salary is greater than 5000
SELECT DEPARTMENT_ID, MIN(SALARY), MAX(SALARY)
FROM EMPLOYEE GROUP BY DEPARTMENT_ID
HAVING MAX(SALARY) > (MIN(SALARY) + 5000)
ORDER BY DEPARTMENT_ID
 Joining Two Tables
 Statement to get the list of employees with their department names
SELECT EMPLOYEE.EMPLOYEE_ID, EMPLOYEE.LAST_NAME,
DEPARTMENT.DEPARTMENT_NAME
10

FROM EMPLOYEE, DEPARTMENT
WHERE DEPARTMENT.DEPARTMENT_ID = EMPLOYEE.DEPARTMENT_ID
 Joining a Table to itself
 Statement to get the list of employees with their supervisor names
SELECT A.EMPLOYEE_ID, A.LAST_NAME, B.LAST_NAME
FROM EMPLOYEE A, EMPLOYEE B
WHERE B.EMPLOYEE_ID = A.SUPERVISOR_ID
 Outer Join
 Normal joins returns rows only if there are matching rows in both the joining
tables. Outer joins returns the rows even if there are no matching rows in the
joining table (with the column from the joining table as Null). Given below is a
statement to get the list of employees with their department names, even if
the department id is not found in department table
SELECT EMPLOYEE.EMPLOYEE_ID, EMPLOYEE.LAST_NAME,
DEPARTMENT.DEPARTMENT_NAME
FROM EMPLOYEE, DEPARTMENT
WHERE DEPARTMENT.DEPARTMENT_ID (+) = EMPLOYEE.DEPARTMENT_ID
Group/Aggregate functions
• SUM () gives the total of all the rows, satisfying any conditions, of the given
column, where the given column is numeric.
• AVG () gives the average of the given column.
• MAX () gives the largest figure in the given column.
• MIN () gives the smallest figure in the given column.
• COUNT() gives the number of rows satisfying the conditions.
• COUNT(*) gives the number of rows in the table.
Other SQL Functions
• ABS() gives the absolute value of the given value
• SQRT() gives the square root of the given value
• POWER(m,n) gives the result mn
• ROUND(n,m) n rounded to m places.
• UPPER - Converts to upper case
• LOWER – Converts to lower case
11

• SUBSTR – Returns a sub string from the source string
• INSTR – Searches for a string in another string.
• NVL – Checks for NULL value
• TRIM, LTRIM, RTRIM – Trims the given string
• PAD, LPAD, RPAD – Pads the character string with specified number of
characters.
• TO_NUMBER, TO_CHAR, TO_DATE – Conversion functions
• ADD_MONTHS – Adds given number of months to a date
• MONTHS_BETWEEN – Gives number of months between two dates.
• LAST_DAY – Returns the last date of the month of a given date
• DECODE – Very powerful function for decoding.
Note: All the above functions can be used in SQL statements (both on SELECT
columns and in WHERE clause).
UNION
The UNION command is used to select related information from two tables. When
using the UNION command all selected columns need to be of the same data
type. With UNION, only distinct values are selected.
SQL Statement 1
UNION
SQL Statement 2
 Statement to get list of all female employees or employees in department 1
without any duplicates
SELECT EMPLOYEE_ID, FIRST_NAME, LAST_NAME FROM EMPLOYEE
WHERE SEX = ‘F’
UNION
UNION ALL
The UNION ALL command is equal to the UNION command, except that UNION
ALL selects all values.
 Statement to get list of all female employees or employees in department 1
with duplicates allowed
12

WHERE SEX = ‘F’
UNION ALL
INTERSECTION
The INTERSECT command is used to find the intersection of two tables.
SQL Statement 1
INTERSECT
SQL Statement 2
 Statement to get list of female employees in department 1
WHERE SEX = ‘F’
INTERSECT
INTERSECT ALL
The INTERSECT ALL command is equal to the INTERSECT command, except that
INTERSECT ALL selects all values.
MINUS
The MINUS command returns rows from first select statement minus the rows
from second select statement.
 Statement to get list of female employees excluding those belong to
department 1
WHERE SEX = ‘F’
MINUS
SELECT EMPLOYEE_ID, FIRST_NAME, LAST_NAME
FROM EMPLOYEE WHERE DEPARTMENT_ID = 1
Tips on Efficient SQL Coding
 Avoid data conversion in the WHERE clause on indexed columns.
 Avoid using SQL functions on the indexed columns used in the WHERE clause.
13

 BETWEEN is more efficient than using >= and <= operators.
 Avoid using % at the beginning of a search string in LIKE predicate.
 Avoid doing arithmetic within a WHERE clause.
 Avoid using the same column for comparison in the WHERE clause more than
once.
 When joining tables, put the indexed columns on the right side of join.
 Make sure that the high order index column is used in the WHERE clause in
case of a multi column indexed table search.
 When using ORDER BY or GROUP BY, choose columns that have an index
defined on them.
 Avoid using literals or variables with greater size or precision for comparison
in the WHERE clause.
 If possible, avoid using combination of IN, LIKE or OR predicates in the
WHERE clause.
 When LIKE or IN predicates are used in a WHERE clause along with ORDER BY
or GROUP BY clauses, a sort of the entire table will occur first before the
WHERE clause is executed. This can be avoided by dynamically creating a
temporary table, loading with selected rows and then applying ORDER BY or
GROUP BY clause to the temporary table.
1.3 Views
The DML statements given above help the users to manipulate the data stored in the
‘conceptual’ relations in the database. Such conceptual relations are sometimes
referred to as base relations. For security and other concerns, sometimes it may be
necessary to prevent direct access to the base relations by users. It is possible to
create ‘virtual relations’ from base relations for different groups of users, exposing
only the relevant data elements to different groups of users. This is possible in SQL
by creating views. A relation in a view is virtual since no corresponding physical
relation exists. A view represents a different perspective of a base relation or
relations. The general syntax of create view statement is:
Create view <view name> as <query expression>
Views are not stored, since the data in the base relations may change. But, the
definition of a view in a create view statement is stored in the system catalog.
14

Whenever, such a virtual relation defined by a view is referred by a query, the view
is recomputed to refresh the tuples in the virtual relation.
Example: Pay_Rate of an employee is confidential in nature and hence not all users
are permitted to see the Pay_Rate of an employee. So, DBA can create a view
EMP_VIEW to prevent viewing Pay_Rate by normal users and give access to this view
rather than giving direct access to the EMPLOYEE table. EMP_VIEW can be defined
as:
Create view EMP_VIEW as (select Emp_Id, Name, Skill from EMPLOYEE)
A view can be deleted from the database by using drop view statement. Syntax of
drop view statement is: Drop view <view name>
The tuples in a view can be updated only under certain conditions. When the tuple in
a view doesn’t map to a single tuple in the base relation, the update operation may
not be possible. Views that involve a join may not be updatable, if they do not
include the primary keys of the base relations.
15

Table of Contents
1.INTRODUCTION TO SQL...................................................................................1
16

Module 3

Recommended

More Related Content

What's hot (20)

Similar to Module 3 (20)

More from cs19club (15)

Recently uploaded (20)

Module 3