DAY – 1 LAB MODULE : SQL

PROCEDURE TO ENTER INTO SPUFI

1. CREATE ONE PDS AS INPUT FILE. XXXXXXXX.DB2.SOURCE

2. CREATE ONE SEQ DS AS OUTPUT FILE. XXXXXXXX.DB2.OUTFILE
3. FROM THE PRIMARY OPTION MENU SELECT M(MORE).
4. SELECT 15
5. SELECT 1 ( MAKE SURE DB2 SUBSYSTEM NAME IS ------)
6. IN SPUFI SCREEN ENTER INPUT DS NAME ALONG WITH MEMBER NAME
‘XXXXXXXX.DB2.SOURCE(SQL1)’
7. IN SPUFI SCREEN ENTER OUTPUT DS NAME
‘XXXXXXXX.DB2.OUTFILE’
8. WRITE SQL QUERY (DATABASE & TABLE SPACE IS SHRDB4.SHRTS4)
9. RUN THE QUERY BY GIVING EDIT;EXECUTE;AUTOCOMMIT; IN
COMMAND & PRESS F3.
10.EXECUTION CODE - SQLCODE 00/100 MEANS PGM EXECUTED SUCCESSFULLY.

SQL - STRUCTURED QUERY LANGUAGE

-----------------------------------------------------------

1) DDL - DATA DEFINITION LANGUAGE

2) DML - DATA MANIPULATION LANGUAGE
3) DCL - DATA CONTROL LANGUAGE
4) TCL - TRANSACTION CONTROL LANGUAGE

DDL: - CONCERNED WITH STRUCTURE OF DB2 OBJECT

----

CREATE - CREATE A NEW TABLE

ALTER - USED TO ALTER AN EXISTING TABLE
DROP - USED TO REMOVE ENTIRE OBJECT
RENAME - USED TO RENAME THE EXISTING TABLE NAME
TRUNCATE – SED TO DELETE ALL RECORDS FOR THE TABLE

DML: - CONCERNED ONLY WITH VALUES

----

INSERT - INSERTING NEW ROWS

UPDATE - MODIFYING THE CONTENTS OF THE RECORDS
DELETE - DELETION OF RECORD
SELECT - USED TO RETRIEVE DATAS

DCL:
----

GRANT - GRANTING PERMISSION TO OTHER USERS

REVOKE- CANCEL PERMISSION WHICH IS GRANTED

TCL:
----

COMMIT - SAVE PERMANENTLY TO DATABASE

ROLLBACK - UNDO CONTROL TO PREVIOUS STATEMENT

SQL 1 : CREATE TABLE

Syntax:

CREATE TABLE <Table Name> (<Field1><Data Type> NOT NULL,

<Field2><Data Type> CONSTRAINT<Constraint Name> PRIMARY
KEY) IN DBMATE1.TSLEMA01;

CREATE TABLE EMPLOYEE (EMPNO INTEGER CONSTRAINT C_EMP

PRIMARY KEY, EMPNM CHAR(25) NOT NULL) IN
DBMATE1.TSLEMA01;

CREATE TABLE EMPLOYEE (EMPNO INTEGER, EMPNM CHAR(25) NOT

NULL, CONSTRAINT C_EMP PRIMARY KEY (EMPNO)) IN
DBMATE1.TSLEMA01;

A sample Table with all data type declared

CREATE TABLE TEST

(M1 CHAR (8) NOT NULL PRIMARY KEY,
M2 VARCHAR (20) NOT NULL,
M3 VARCHAR (10) NOT NULL WITH DEFAULT,
M4 INTEGER,
M5 SMALLINT,
M6 DATE,
M7 TIME,
M8 TIMESTAMP,
M9 DECIMAL(6,3)
) IN DBMATE1.TSLEMA01;

Other Data types of table can be

VARCHAR(20), INT or INTEGER, SMALLINT, DATE, TIME, TIMESTAMP, DEC(4,2),
NUMERIC(4,2), FLOAT, REAL, CLOB, BLOB, GRAPHICS, DBCLOB.

CREATE TABLE EMPLOYEE

( EMPID CHAR(5) NOT NULL,
EFNAME CHAR(15) NOT NULL,
ELNAME CHAR(15) NOT NULL,
EMPDOB DATE NOT NULL,
EMPSAL DECIMAL(7,2),
EMPDEPT CHAR(5) NOT NULL,
PRIMARY KEY (EMPID)) IN DBMATE1.TSLEMA01;

INTEGRITY CONSTRAINTS
---------------------
- USED TO PREVENT INVALID DATA ENTRY IN A DATABASE TABLE.
- INTEGRITY REFERS ACCURACY, VALIDITY OR CORRECTNESS OF DATA IN
DATABASE.

3 TYPES OF INTERITY CONSTRIANTS:

-------------------------------
DOMAIN INTERGRITY - NOT NULL, CHECK
ENTITY INTEGRITY - PRIMARY KEY, UNIQUE
 REFERENTIAL INTERGITY - FOREIGN KEY

DOMAIN INTEGRITY:
-----------------
NOT NULL:
---------
- BY DEFAULT ALL COLUMNS WILL ALLOW NULL VALUES. IF NOT NULL ISSPECIFIED FOR A
COLUMN, THEN SOME VALUE HAS TO BE ENTERED TO THE PARTICULAR COLUMN

NULL (Default),
NOT NULL,
NOT NULL WITH DEFAULT,
NOT NULL WITH DEFAULT ‘HELLO’
NOT NULL WITH DEFAULT 1234
NOT NULL WITH DEFAULT '7/25/1977'
NOT NULL WITH DEFAULT ‘10.30.00’

DEFAULT DEPENDS ON THE DATA TYPE

ZERO – INT / SMALLINT / DECIMAL / NUMERIC

SPACES – CHAR / VARCHAR
CURRENT DATE – DATE
CURRENT TIME – TIME
CURRENT TIMESSTAMP – TIMESTAMP

CHECK CONSTRIANT:
-----------------

- IT SETS A RANGE AND IF THE RANGE IS EXCEEDED, THE CONSTRAINT IS SET TO BE

VIOLATED.

- USED TO CHECK VALUE FOR A SPECIFIED COLUMN WHETHER IT IS BELOW OR BEYOND THE
SPECIFIED LIMIT.

- CREATE TABLE EMPLOYEE (EMPNO INTEGER NOT NULL, EMPNM CHAR(25) NOT NULL,
SALARY INTEGER CHECK (SALARY > 15000))IN DBMATE1.TSLEMA01;

- CREATE TABLE TEST (RNO INT, NAME VARCHAR (10),

SEX CHAR (1) CHECK (SEX='M' OR SEX='F' ), MARK INT) IN DB.TS

- CREATE TABLE TEST(EMPID INT, EMPSAL INT CHECK (SAL<100000), DEPT CHAR(6))
IN DB.TS;

- CREATE TABLE TEST(EMPID INT, EMPSAL INT EMPSAL DEC(4,0) (CHECK EMPSAL>=2000
AND EMPSAL <=4000) IN DB.TS;

ENTITY INTEGRITY CONSTRIANT:

----------------------------

PRIMARY KEY CONSTRIANT:

-----------------------
- USED TO REJECT DUPLICATE AND NULL VALUES.
- CAN BE ONLY ONE PRIMARY KEY IN A TABLE.
- CAN ASSIGN A SINGLE PRIMARY KEY OR TO A COMBINATION OF COLUMNS, WHICH IS
CALLED AS COMPOSITE PRIMARY KEY.

RULES:
------
- DEFINE NOT NULL CONSTRIANT FOR PRIMARY KEY COLUMN.
- CREATE UNIQUE INDEX.

CREATING PRIMARY KEY:

---------------------

TABLE LEVEL CONSTRIANT:

-----------------------
- CREATE TABLE TEST (ENO INT NOT NULL, ENAME CHAR(20),
PRIMARY KEY(ENO) ) IN DB.TS;

COLUMN LEVEL CONSTRIANT:

------------------------
- CREATE TABLE TEST (ENO INT NOT NULL PRIMARY KEY, ENAME CHAR(20))IN DB.TS;

INDEX:
------
INDEX CONTAINS KEY & ADDRESS (LOCATION)

1. NON-UNIQUE INDEX
2. UNIQUE INDEX

DEFAULT VALUE - NON UNIQUE INDEX

Syntax: CREATE [UNIQUE] INDEX <Index Name> ON <Table Name><Field1

(Order), Field2 (Order), ….>

Order Can be of ascending and descending.

EG:
---
CREATE UNIQUE INDEX <INDEX-NAME> ON <TNAME>(<COL-NAME>)

CREATE UNIQUE INDEX:

--------------------
- CREATE UNIQUE INDEX IND1 ON TEST (ENO);

COMPOSITE KEY:
--------------
- WHEN A KEY IS MADE FROM MORE THAN ONE FIELD IT IS CALLED COMPOSITE KEY.

EG.

- CREATE TABLE TEST(ENO INT NOT NULL, ENAME CHAR(20), SAL INT NOT NULL,
PRIMARY KEY(ENO,SAL)) IN DB.TS;

COMPOSITE INDEX:
----------------
- WHEN AN INDEX IS MADE FOR MORE THAN ONE FIELD IT IS CALLED COMPOSITE INDEX.

Eg.
- CREATE UNIQUE INDEX IND2 ON TEST(ENO,SAL);
ALTERNATE KEY:
--------------
- UNIQUE AND NON-UNIQUE KEY
- CAN BE MORE THAN ONE ALTERNATE KEY IN SINGLE TABLE.
- CAN ASSIGN A COMBINATION OF COLUMNS CALLED AS COMPOSITE ALTERNATE KEY.

RULES:
------
- DEFINE NOT NULL FOR ALTERNATE KEY WITH UNIQUE SYNTAX.
- CREATE UNIQUE INDEX.

EX:
---
CREATE TABLE TEST(ENO INTEGER NOT NULL PRIMARY KEY, ENAME VARCHAR(10) UNIQUE
NOT NULL, PAN NUMERIC(5) UNIQUE NOT NULL) IN DB.TS;

CREATE UNIQUE INDEX A1 ON TEST(ENO) ;

CREATE UNIQUE INDEX C1 ON TEST(PAN) ;

CREATE NON-UNIQUE INDEX:

--------------------
- CREATE INDEX B1 ON TEST(ENAME) ;

COMPOSITE ALTERNATE KEY:

-------------------------
CREATE TABLE EMP(ENO INTEGER NOT NULL PRIMARY KEY, ENAME VARCHAR(10) NOT NULL,
SAL NUMERIC(5) NOT NULL, UNIQUE(ENAME,SAL) ) IN SAMDB5.SAMSP5;

CREATE UNIQUE INDEX IND1 ON TEST(ENO) ;

CREATE UNIQUE INDEX IND4 ON TEST(ENAME,SAL);

CANDIDATE KEY:
--------------
- MORE THAN ONE KEY IN A TABLE BUT ONLY ONE PRIMARY KEY .

Another way to create table

CREATE TABLE NEWTABLE LIKE EMPLOYEE IN DB.TS;

OPERATORS (PREDICATES) IN DB2:

ARITHMETIC OPERATORS : +,-,*,/

COMPARISON OPERATORS : <,>,<=,>=,=,<>,IN,NOT IN,LIKE,BETWEEN
LOGICAL OPERATORS : AND, OR, NOT

SQL 2 : CREATE INDEX

CREATE UNIQUE INDEX IDX2 ON EMPLOYEE(EMPID);

CREATE UNIQUE INDEX IDXIND2 ON EMPLOYEE(EMPID DESC);

SQL 3 : INSERT

INSERT INTO EMPLOYEE (EMPID,EFNAME,ELNAME,EMPDOB,EMPSAL,EMPDEPT)

VALUES('A0001','JAIKUM','PRADEEP','7/25/1977',7000,'D0001');
INSERT INTO EMPLOYEE VALUES ('C0001','JAIKUM','PRADEEP','7/25/1977',NULL,'D0001');

INSERT INTO EMPLOYEE VALUES ('D0001','JAIKUM','PRADEEP','7/25/1977',DEFAULT,

'D0001');

INSERT INTO EMP VALUES(‘D0002’, CURRENT DATE, TIME(CURRENT TIMESTAMP) )

NOTE:
Specify DATE in ‘YYYY-MM-DD' format or in ‘MM/DD/YYYY’ format, TIME in ‘24.00.00’
format, TIMESTAMP in ‘9999-12-31-24.00.00.000000000’ format which is date and time
by year, month, day, hour, minute, second, and microsecond.

Make some more entries as below

A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001

A0003 PRIYA PV 1897-04-05 6000.00 D0002
B0001 ANURAG GN 1997-07-05 12000.00 D0003
B0004 ABHILASH GN 1900-12-05 10000.00 D0001
E0001 PRADEEP PV 1999-11-05 15000.00 D0001
E0003 SEEMA ROY 1977-08-30 8000.00 D0005
E0005 SINI VINOD 1956-05-23 20000.00 M0001
E0007 DILEEP KUMAR 1988-07-12 8000.00 M0001
E0008 DEEP KU 1981-04-12 5000.00 E0002
E0009 MINI MA 1981-08-07 9000.00 E0002

MULTI-ROW INSERT

INSERT INTO table2 (column1, column2, column3, ...)

SELECT column1, column2, column3, ...
FROM table1
WHERE condition;

INSERT INTO TABLE2 SELECT * FROM TABLE1;

SQL 4 : SELECT

SYNTAX:

SELECT * FROM <TABLE NAME>; - * REFERS TO ALL FIELDS.

SELECT * FROM <TABLE NAME>
[WHERE <CONDITION>]
[GROUPBY <COL>]
[HAVING <CONDITION>]
[ORDER BY <COL>];

SELECT * FROM EMPLOYEE;

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

---------+---------+---------+---------+---------+---------+------+---
A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001
A0003 PRIYA PV 1897-04-05 6000.00 D0002
B0001 ANURAG GN 1997-07-05 12000.00 D0003
B0004 ABHILASH GN 1900-12-05 10000.00 D0001
E0001 PRADEEP PV 1999-11-05 15000.00 D0001
E0003 SEEMA ROY 1977-08-30 8000.00 D0005
E0005 SINI VINOD 1956-05-23 20000.00 M0001
E0007 DILEEP KUMAR 1988-07-12 8000.00 M0001
E0008 DEEP KU 1981-04-12 5000.00 E0002
E0009 MINI MA 1981-08-07 9000.00 E0002

SQL 5 : DISPLAY 2 FIELDS - SELECT

SELECT EMPID, EFNAME FROM EMPLOYEE;

OUTPUT

A0001 JAIKUM
A0003 PRIYA
B0001 ANURAG
B0004 ABHILASH
E0001 PRADEEP
E0003 SEEMA
E0005 SINI
E0007 DILEEP
E0008 DEEP
E0009 MINI

SQL 6 : RETRIEVAL WITH WHERE - SELECT

SELECT * FROM EMPLOYEE WHERE EMPID='E0001';

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

---------+---------+---------+-------+---------+---------+---------+---
E0001 PRADEEP PV 1999-11-05 15000.00 D0001

SQL 7 : RETRIEVAL WITH WHERE - SELECT

SELECT * FROM EMPLOYEE WHERE EMPDOB='1977-07-25'

SELECT * FROM EMPLOYEE WHERE EMPDEPT='D0001';

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

------+---------+---------+---------+---------+---------+---------+----
A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001
B0004 ABHILAS GN 1977-07-25 10000.00 D0001
E0001 PRADEP PV 1977-07-25 15000.00 D0001
E0005 SINI VINOD 1977-07-25 20000.00 D0001
E0007 DILIP KUMAR 1977-07-25 8000.00 D0001

SQL 8 : RETRIEVAL WITH ORDER BY - DESC - SELECT

ORDER BY clauses is that all columns identified in the ORDER BY clause

must appear in the SELECT clause.
SELECT * FROM EMPLOYEE ORDER BY EMPID DESC;

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

----+---------+---------+---------+---------+---------+---------+------
E0009 MINI MA 1981-08-07 9000.00 E0002
E0008 DEEP KU 1981-04-12 5000.00 E0002
E0007 DILEEP KUMAR 1988-07-12 8000.00 M0001
E0005 SINI VINOD 1956-05-23 20000.00 M0001
E0003 SEEMA ROY 1977-08-30 8000.00 D0005
E0001 PRADEEP PV 1999-11-05 15000.00 D0001
B0004 ABHILASH GN 1900-12-05 10000.00 D0001
B0001 ANURAG GN 1997-07-05 12000.00 D0003
A0003 PRIYA PV 1897-04-05 6000.00 D0002
A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001

SQL 9 : RETRIEVAL WITH ORDER BY ASC - SELECT

SELECT * FROM EMPLOYEE ORDER BY EMPSAL ASC;

OUTPUT

---------+---------+---------+---------+---------+---------+---------+
EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT
---------+---------+---------+---------+---------+---------+---------+
E0008 DEEP KU 1981-04-12 5000.00 E0002
A0003 PRIYA PV 1897-04-05 6000.00 D0002
A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001
E0007 DILEEP KUMAR 1988-07-12 8000.00 M0001
E0003 SEEMA ROY 1977-08-30 8000.00 D0005
E0009 MINI MA 1981-08-07 9000.00 E0002
B0004 ABHILASH GN 1900-12-05 10000.00 D0001
B0001 ANURAG GN 1997-07-05 12000.00 D0003
E0001 PRADEEP PV 1999-11-05 15000.00 D0001
E0005 SINI VINOD 1956-05-23 20000.00 M0001

SQL 10 : RETRIEVAL WITH > - SELECT

SELECT EMPID, EFNAME FROM EMPLOYEE WHERE EMPSAL>10000;

OUTPUT

EMPID EFNAME
---------+---------+---------+---------+---------+---
B0001 ANURAG
E0001 PRADEEP
E0005 SINI

SELECT EMPID, EFNAME FROM EMPLOYEE WHERE EMPSAL>=10000;

SELECT EMPID, EFNAME FROM EMPLOYEE WHERE EMPSAL<10000;

SELECT EMPID, EFNAME FROM EMPLOYEE WHERE EMPSAL<=10000;

SELECT EMPID, EFNAME FROM EMPLOYEE WHERE EMPSAL<>10000;

SQL 11 : RETRIEVAL WITH > AND < - SELECT

SELECT * FROM EMPLOYEE WHERE EMPSAL>5000 AND EMPSAL<15000;

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

---------+---------+---------+-------+---------+---------+---------+---
A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001
A0003 PRIYA PV 1897-04-05 6000.00 D0002
B0001 ANURAG GN 1997-07-05 12000.00 D0003
B0004 ABHILASH GN 1900-12-05 10000.00 D0001
E0003 SEEMA ROY 1977-08-30 8000.00 D0005
E0007 DILEEP KUMAR 1988-07-12 8000.00 M0001
E0009 MINI MA 1981-08-07 9000.00 E0002

SQL 12 : RETRIEVAL WITH LIKE - SELECT

SELECT * FROM EMPLOYEE WHERE EMPID LIKE 'B%';

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

---------+---------+---------+--------+---------+---------+---------+--
B0001 ANURAG GN 1997-07-05 12000.00 D0003
B0004 ABHILASH GN 1900-12-05 10000.00 D0001

SQL 13 : RETRIEVAL WITH LIKE - SELECT

SELECT * FROM EMPLOYEE WHERE ELNAME LIKE 'R%';

OUTPUT

EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT

---------+---------+---------+---------+---------+---------+---------+-
E0003 SEEMA ROY 1977-08-30 8000.00 D0005

SELECT * FROM EMPLOYEE WHERE ELNAME LIKE 'R___';

SELECT * FROM EMP WHERE EFNAME LIKE '%A';

SELECT * FROM EMP WHERE ELNAME LIKE '_A';

SQL 14 : SELECT - IN

SELECT * FROM EMPLOYEE WHERE EMPDEPT IN (‘D0001’, ‘D0002’, ‘D0003’);

SELECT * FROM EMPLOYEE WHERE EMPDEPT NOT IN (‘D0001’, ‘D0002’, ‘D0003’);

SQL 15 : SELECT - BETWEEN >= AND <=

SELECT * FROM EMPLOYEE WHERE EMPSAL BETWEEN 10000 AND 20000;

SELECT * FROM EMPLOYEE WHERE EMPSAL NOT BETWEEN 10000 AND 20000;

SELECT * FROM EMPLOYEE WHERE EMPSAL >=10000 AND EMPSAL <= 20000;

SELECT * FROM EMPLOYEE WHERE EMPSAL < 10000 OR EMPSAL > 20000;

SELECT * FROM EMPLOYEE WHERE EMPDEPT=D0001 OR EMPDEPT = D0002);

SQL 16 : AGGREGATE FUNCTION

SELECT AVG(EMPSAL) FROM EMPLOYEE;

SELECT COUNT(*) FROM EMPLOYEE ;

SELECT COUNT(EMPSAL) FROM EMPLOYEE ;

SELECT MIN(EMPSAL) FROM EMPLOYEE;

SELECT MAX(EMPSAL) AS MAXX FROM EMPLOYEE;

SELECT SUM(EMPSAL) AS SUMM FROM EMPLOYEE;

SELECT AVG(EMPSAL) AS AVGG FROM EMPLOYEE;

SELECT COUNT(*) AS COUNT1 FROM EMPLOYEE;

SELECT COUNT(ELNAME) AS NAMEIS FROM EMPLOYEE;

SQL 17 : AGGREGATE FUNCTION

SELECT DATE(EMBDOB) FROM EMPLOYEE; Returns 2016-01-05

SELECT DAY(EMPDOB) FROM EMPLOYEE; Returns in the range 1 to 31. NO OF DAYS

FROM BEGINNING MONTH

SELECT DAYOFWEEK(‘2016-12-03’) FROM SYSIBM.SYSDUMMY1; Returns 7 for Saturday.

SELECT DAYOFYEAR(EMPDOB) FROM EMPLOYEE; Returns day from January 1st.

SELECT WEEK(EMPDOB) FROM EMPLOYEE; Returns WEEK from January 1st.

SELECT QUARTER(EMPDOB) FROM EMPLOYEE; Returns QUARTER(1,2,3,4) from January 1st.

SELECT MONTH(EMPDOB) FROM EMPLOYEE; Returns in the range 1 to 12.

SELECT YEAR(EMPDOB) AS YEAR1 FROM EMPLOYEE; Returns 2016, returns year part

SELECT DAYS(EMPDOB) AS DAYS1 FROM EMPLOYEE; Returns 735968 of 2016-01-05FROM

1600, 31ST DEC.

SELECT TIME("19:30:10") FROM SYSIBM.SYSDUMMY1; Returns 19:30:10

SELECT TIME(DOT), HOUR(DOT), SECOND(DOT), MINUTE(DOT) FROM EMPLOYEE;

SELECT TIMESTAMP(DATETIME) FROM EMPLOYEE;

SELECT ADD_MONTHS (CURRENT_DATE,5) FROM SYSIBM.SYSDUMMY1;

SELECT DAYS (CURRENT DATE) - DAYS (DATE('1999-10-22')) FROM SYSIBM.SYSDUMMY1;

Calculates the difference between two dates

SELECT LAST_DAY(CURRENT DATE) FROM SYSIBM.SYSDUMMY1; RETURNS THE LAST DAY OF

THE MONTH FOR THE SPECIFIED DB2 DATE OR TIMESTAMP

SELECT NEXT_DAY(CURRENT DATE,'FRIDAY') FROM SYSIBM.SYSDUMMY1; RETURNS A

TIMESTAMP SPECIFYING THE FIRST FRIDAY AFTER TODAY.

SELECT LOCATE(‘N’,ELNAME) FROM EMPLOYEE; Returns first N position in ELNAME

SELECT LOCATE(‘N’,ELNAME,10) FROM EMPLOYEE; Returns first N in ELNAME

From 10th position onwards

SELECT RIGHT(ENAME,2) FROM EMPLOYEE; Returns last two characters of all the
ENAME column

SELECT RIGHT('SQL Tutorial', 3) FROM SYSIBM.SYSDUMMY1; Returns ial

SELECT LEFT(ENAME,2) FROM EMPLOYEE; Returns two position from left for all column of
ENAME

SELECT LEFT('SQL Tutorial', 3) FROM SYSIBM.SYSDUMMY1; Returns SQL

SELECT LENGTH(EFNAME) FROM EMPLOYEE1;RETURNS THE LENGTH OF THE COLUMN

SELECT LENGTH(EMPNAME) FROM EMPLOYEE; RETURNS THE MAX SIZE OF THE COLUMN i.e
10 , IF VARCHAR AND THE VALUE ENTERED IS ABCD THEN THE LENGTH RETURNS4.

SELECT SUBSTR(EFNAME,3,2) FROM EMPLOYEE;

SELECT LOWER(EFNAME) FROM EMPLOYEE;

SELECT UPPER(EFNAME) FROM EMPLOYEE;

SELECT CONCAT('MR.',ENAME) FROM EMPLOYEE;

SELECT 'MR.'||ENAME||'@'||'YAHOO.COM' FROM EMPLOYEE;

SELECT REPLACE('JACK AND JUE','J','BL') FROM EMPLOYEE; => BLACK AND BLUE

SELECT RTRIM('SQL Tutorial ') AS RightTrimmedString; Removes trailing spaces

from a string.

SELECT LTRIM(' SQL Tutorial') AS LeftTrimmedString; RemoveS leading spaces

from a string

SELECT STRIP(NAME) FROM EMPLOYEE - leading/trailing blank spaces will be removed

SELECT EMPNO ,STRIP(EMPNO,L,'*') FROM EMPLOYEE - "STRIPED LEADING *“

SELECT EMPNO ,STRIP(EMPNO,T,'*') FROM EMPLOYEE - "STRIPED TRAILING”

SELECT EMPNO ,STRIP(EMPNO,B,'*') FROM EMPLOYEE - "STRIPED BOTH *"

SELECT MOD(M,N) FROM EMPLOYEE; MOD(11,4) => 11/4 => 3 =>REMAINDER

SELECT POWER(3,2) FROM EMPLOYEE => 9

SELECT SIGN(EMPSAL) FROM EMPLOYEE; Returns 1 if EMPSAL > 0, Returns 0 if

EMPSAL = 0 and Returns -1 if EMPSAL is < 0

SELECT ROUND(EMPSAL) FROM EMPLOYEE;

SELECT SQRT(36) FROM EMPLOYEE =>6

SELECT ROUND(15.193,2) FROM EMPLOYEE =>15.2

SELECT TRUNCATE(15.193,1) FROMEMPLOYEE =>15.1

SELECT TRANSLATE(‘BACK’, ‘R’, ‘C’) FROM SYSIBM. SYSDUMMY1; THE CHARACTER

STRING ‘C’ IS REPLACED WITH THE CHARACTER STRING ‘R’.

SELECT REPEAT(‘HELLO',2) FROM SYSIBM.SYSDUMMY1;

VALUE & COALESCE & IFNULL are both same

SELECT VALUE(ENAME,'MAINFRAME') FROM EMPLOYEE => when the name is null the second
parameter 'MAINFRAME' will be displayed

SELECT EMPNO, EMPNAME, EMPSAL, VALUE(EMPSAL,0) FROM TESTDBP;

SELECT EMPNO, EMPNAME, EMPSAL, COALESCE(EMPSAL,0) FROM TESTDBP;

SELECT DEPTNO, DEPTNAME, COALESCE(MGRNO, 'ABSENT') FROM DEPARTMENT;

SELECT EMPCD,IFNULL(EMPNAME,‘HELLO') FROM EMPPLYEE; Same as VALUE

SELECT NULLIF(CITY,'MUMBAI') FROM EMPLOYEE =>when CITY=MUMBAI, NULL will be

displayed

SQL 18 : RETRIEVAL WITH COMPUTATION

SELECT EMPSAL+500 AS ABC FROM EMPLOYEE WHERE EMPDEPT='E0002';

OUTPUT
ABC

5500.00
9500.00

SQL 19 : RETRIEVAL WITH COMPUTATION

SELECT EMPID, EFNAME, ELNAME, EMPSAL-5000 AS BONUS FROM EMPLOYEE WHERE EMPDEPT
LIKE 'M%';
OUTPUT
15000.00
3000.00

SQL 20 : SELECT WITH LOGICAL OPERATORS:

SELECT * FROM EMPLOYEE WHERE EMPSAL>4000 AND EMPSAL<= 5000;

SELECT * FROM EMPLOYEE WHERE EMPSAL>4000 OR EMPSAL<8000;

SQL 21 : NULL RETRIEVAL

INSERT INTO EMPLOYEE (EMPID,EFNAME,ELNAME,EMPDOB,EMPSAL,EMPDEPT)

VALUES('A000N','JAIKUM','PRADEEP','7/25/1977',NULL,'N0001');

SELECT ELNAME, EFNAME FROM EMPLOYEE WHERE EMPSAL IS NULL;

OUTPUT
-------

ELNAME EFNAME
---------+---------+----
PRADEEP JAIKUM

SELECT ELNAME, EFNAME FROM EMPLOYEE WHERE EMPSAL IS NOT NULL;

ELNAME EFNAME
---------+---------+-----
PRADEEP JAIKUM
PV PRIYA
GN ANURAG
GN ABHILAS
PV PRADEP
ROY SEEMA
VINOD SINI
KUMAR DILIP
KU DEEP
MA MINI

SQL 22 : GROUP BY & SUM

SELECT EMPDEPT, SUM(EMPSAL) FROM EMPLOYEE GROUP BY EMPDEPT;

OUTPUT

EMPDEPT SUM(EMPSAL) IN EACH DEPT

D0001 60000.00
D0002 6000.00
D0003 12000.00
D0005 8000.00
E0002 14000.00

SQL 23 : SELECT WITH ORDER BY

- ARRANGING IN ASCENDING OR DESCENDING ORDER.
- BY DEFAULT ASCENDING ORDER

SELECT * FROM EMPLOYEE ORDER BY ENO DESC;

SELECT * FROM EMPLOYEE WHERE EMPSAL>1000 ORDER BY ENAME;

SELECT EMPID, EFNAME, ELNAME FROM EMPLOYEE ORDER BY 3 DESC;

SQL 24 : GROUP BY & HAVING

- USED TO DISPLAY THE VALUES GROUPED BY ONE PARTICULAR COLUMN VALUE.

- The GROUP BY clause is normally used along with five built-in aggregate
functions (SUM, AVG, MAX, MIN, COUNT)

SELECT EMPDEPT, MAX (EMPSAL) FROM EMPLOYEE GROUP BY EMPDEPT ;

OUTPUT:
-------
DEPT MAX(SAL)
--- --------
D0001 20000.00
D0002 6000.00
D0003 12000.00
D0005 8000.00
E0002 9000.00

NOTE : Example of ERROR

-SELECT ELNAME,AVG(SALARY) FROM EMPLOYEE GROUP BY DEPT;

Here ELNAME is not a group column and not included in GROUP BY clause.

HAVING:
-------
- WHERE IS APPLIED TO ELIMINATE ROWS FROM THE TABLE WHEREAS HAVING IS USED TO
ELIMINATE GROUPS.
- Conditions in the HAVING clause are applied after groups are formed.
- Search condition of the HAVING clause examines the grouped rows and produces
a row for each group where the search condition in the HAVING clause is true.

SELECT EMPDEPT, MAX(EMPSAL) FROM EMPLOYEE GROUP BY EMPDEPT HAVING COUNT(*)>=2;

OUTPUT:
-------
EMPDEPT MAX(SAL)
--- --------
D0001 20000.00
E0002 9000.00

Eg.

- SELECT EMPDEPT, AVG(EMPSAL), MAX(EMPSAL), MIN(EMPSAL) FROM EMPLOYEE

WHERE EMPDEPT = 'D0001' GROUP BY EMPDEPT;

OUTPUT
------
EMPDEPT AVG(SAL) MAX(SAL) MIN(SAL)

---------+---------+---------+---------+---------

D0001 12000.00 20000.00 7000.00

SQL 25 : SELECT WITH DISTINCT:

---------------
- TO GET UNIQUE
- TO ELIMINATE DUPLICATES

SELECT DISTINCT EMPSAL FROM EMPLOYEE;

EMPSAL
---------+----
5000.00
6000.00
7000.00
8000.00
9000.00
10000.00
12000.00
15000.00
20000.00

SELECT COUNT(DISTINCT EMPDEPT) FROM EMPLOYEE;

SQL 25 : SELECT WITH FETCH:

SELECT * FROM EMPLOYEE FETCH FIRST 10 RECORDS ONLY;

LAST 10 ROWS

SELECT * FROM EMPLOYEE ORDER BY EMPNO DESC FETCH FIRST 10 ROWS ONLY;

SQL 25 : UPDATE

SYNTAX:
-------------
UPDATE <TABLE NAME> SET <COLUMN NAME>=<VALUE> WHERE <CONDITION>

EX:
-----
UPDATE EMPLOYEE SET EMPDEPT='E0005' WHERE EMPID = 'E0008';

UPDATE EMPLOYEE SET TOT=MARK1+MARK2 WHERE EMPID=’E1000’;

UPDATE EMPLOYEE SET

EMPDOB='10/2/1988',
EMPSAL=9999,
EMPDEPT=NULL
WHERE EFNAME='PRIYA';
SQL 26 : DELETE

SYNTAX:

DELETE FROM <TABLE NAME> [ WHERE <CONDITION> ]

EX:
-----

DELETE FROM EMPLOYEE;

DELETE FROM EMPLOYEE WHERE EMPID=’E0001’;

DELETE FROM EMPLOYEE WHERE EFNAME='MINI';

DELETE FROM EMPLOYEE WHERE EMPNAME IS NULL;

NOTE:

For DELETE & SELECT, it should be IS NULL, but in case UPDATE, it should be = NULL.

SQL 27 : TRUNCATE

TRUNCATE TABLE EMPLOYEE; The TRUNCATE statement DELETES all of the records from a table.

DAY - 2

SQL 28 : REFERENTIAL INTEGRITY

 These constraints are used to establish Parent – Child relationship

between two tables having common column.
 To establish this relationship, a column in the parent table should be
defined as primary key and same column in the child table should be
foreign key.
 The foreign key column in the child should refer to corresponding column
in the primary key or UNIQUE NOT NULL key.

Syntax:

CREATE TABLE <Child Table Name> (<Field1><Data Type> NOT NULL, <Field2><Data
Type> CONSTRAINT<Constraint Name> REFERENCES <Parent Table Name (<Field>)>)

Or

CREATE TABLE <Child Table Name> (<Field1><Data Type> NOT NULL, FOREIGN KEY
<Field2><Data Type> CONSTRAINT<Constraint Name> REFERENCES <Parent Table Name
(<Field>)>)

ON INSERT RULES

WE CAN NOT INSERT ANY ROW IN FOREIGN KEY OF CHILD TABLE THAT IS NOT PRESENT IN
PARENT (PRIMARY) KEY OF PARENT TABLE.

DELETE RULES
---------------
USED TO CHECK WHAT HAPPENS TO A FOREIGN KEY OF A CHILD TABLE WHEN A ROW IN A
PARENT TABLE IS DELETED.

1. ON DELETE RESTRICT (DEFAULT) or ON DELETE NO ACTION

DOES NOT ALLOW TO DELETE A PARENT ROW WHEN DEPENDENTS ARE EXISTING.WHEN THAT
PARTICULAR CHILD RECORD IS DELETED, DELETION IS POSSIBLE IN PARENT TABLE.

2. ON DELETE CASCADE

IF A ROW IN PARENT TABLE IS DELETED, THE CORRESPONDING ROW IN THE CHILD TABLE
WILL ALSO BE DELETED.

3. ON DELETE SET NULL

IF A ROW IN PARENT TABLE IS DELETED, THE CORRESPONDING FOREIGN KEY ENTRY WILL
BE SET TO NULL VALUE.

NOTE:
-----

WHEN A PARENT TABLE IS DROPPED, REFERENTIAL INTEGRITY CONSTRAINT WILL BE

DROPPED WHEREAS THE CHILD TABLE WILL EXIST.

PARENT TABLE

STEP1. CREATE TABLE DEPTS(DEPT_ID CHAR(4) NOT NULL,

DEPT_NM CHAR(8) NOT NULL,
MGR_ID CHAR(4) NOT NULL,
PRIMARY KEY(DEPT_ID))
IN DB.TS;

STEP2. CREATE UNIQUE INDEX DEPTIDX ON DEPTS(DEPT_ID);

CHILD TABLE

STEP3. CREATE TABLE EMP(EMP_ID CHAR(4) NOT NULL,

EMP_NM CHAR(8) NOT NULL,
SALARY DECIMAL(6,2),
DEPT_ID CHAR(4) NOT NULL,
PRIMARY KEY(EMP_ID),
FOREIGN KEY(DEPT_ID) REFERENCES
DEPTS(DEPT_ID) ON DELETE
CASCADE/RESTRICT/SET NULL)
IN DB.TS;

STEP4. CREATE UNIQUE INDEX EMPLSIDX ON EMP(EMP_ID);

NOTE:
1. IF REFERENCES DEPTS – is mentioned then by default, it refers to the primary
key of the parent table, if u want to refer to UNIQUE field, then specify
REFERENCES DEPTS (UNIQUE KEY FIELD NAME).
 2. WHEN A PARENT TABLE IS DROPPED, REFERENTIAL INTEGRITY CONSTRAINT WILL BE
DROPPED WHEREAS THE CHILD TABLE WILL EXIST.
3. A FOREIGN KEY constraint does not have to be linked only to a PRIMARY KEY
constraint in another table; it can also be defined to reference the
columns of a UNIQUE constraint in another table.
4. Unlike primary keys, foreign keys can contain duplicate values. Also, it is
OK for them contain NULL values. Indexes aren't automatically created for
foreign keys; however, as a DBA, you can define them. A table is allowed to
contain more than one foreign key.
5. It is perfectly fine to have two foreign key columns referencing the same
primary key column in a different table since each foreign key value will
reference a different record in the related table.

SQL 29 : SELECT CASE

SELECT EMPID, EFNAME, EMPSAL,

CASE
WHEN EMPSAL <= 1000 THEN 'BELOW AVERAGE'
WHEN EMPSAL >= 1001 AND EMPSAL <=2000 THEN 'AVERAGE'
WHEN EMPSAL >= 2001 THEN 'ABOVE AVERAGE'
END AS SALARYRANGE FROM EMPLOYEE;
OUTPUT
------------
EMPID EFNAME EMPSAL SALARYRANGE
1001 RAJ 9000 AVERAGE
1002 HARI 12000 ABOVE AVERAGE
1003 VEENA 5000 BELOW AVERAGE

SQL 30 : JOIN

 THE PURPOSE OF A JOIN IS TO COMBINE THE DATA ACROSS TABLES.

 A JOIN IS ACTUALLY PERFORMED BY THE WHERE CLAUSE WHICH COMBINES THE
SPECIFIED ROWS OF TABLES.
 IF A JOIN INVOLVES IN MORE THAN TWO TABLES THEN ORACLE JOINS FIRST TWO
TABLES BASED ON THE JOINS CONDITION AND THEN COMPARES THE RESULT WITH
THE NEXT TABLE AND SO ON.
 MAXIMUM NUMBER OF TABLES THAT CAN BE JOINED IS 15.

TYPES
EQUI JOIN
NON-EQUI JOIN
SELF JOIN
CROSS JOIN
INNER JOIN
OUTER JOIN
 LEFT OUTER
 RIGHT OUTER
 FULL OUTER

NOTE:
WHEN CODING A JOIN, WE MUST TAKE EXTRA CARETO CODE PROPER
 MATCHING PREDICATE FOR EACHTABLE BEING JOINED. FAILURE TO
DO SO CAN RESULTIN A CARTESIAN PRODUCT.

STEP1

CREATE TABLE DEPT

(
DEPTNO CHAR(2) NOT NULL,
DNAME CHAR(10) NOT NULL,
LOC CHAR(10) NOT NULL,
PRIMARY KEY (DEPTNO)
) IN SHRDB4.SHRTS4;

STEP2

CREATE UNIQUE INDEX IDXJ1 ON DEPT(DEPTNO);

STEP3

SQL> INSERT INTO DEPT VALUES (‘10’,’MKT’,’HYD’);

SQL> INSERT INTO DEPT VALUES (‘20’,’FIN’,’BANG’);
SQL> INSERT INTO DEPT VALUES (‘30’,’HR’,’BOMBAY’);

STEP4

SQL>SELECT * FROM DEPT;

DEPTNO DNAME LOC

------ ---------- ----------
10 MKT HYD
20 FIN BANG
30 HR BOMBAY

STEP5

CREATE TABLE EMP

(
EMPNO CHAR(3) NOT NULL,
ENAME CHAR(10) NOT NULL,
JOB CHAR(10) NOT NULL,
MGR CHAR(4),
DEPTNO CHAR(2),
PRIMARY KEY (EMPNO)
) IN SHRDB4.SHRTS4;

STEP6

CREATE UNIQUE INDEX IDXJ2 ON EMP (EMPNO);

STEP7

SQL> INSERT INTO EMP VALUES (‘111’,’SAKET’,’ANALYST’,’444’,’10’);

SQL> INSERT INTO EMP VALUES (‘222’,’SUDHA’,’CLERK’,’333’,’20’);
SQL> INSERT INTO EMP VALUES (‘333’,’JAGAN’,’MANAGER’,’111’,’10’);
SQL> INSERT INTO EMP VALUES (‘444’,’MADHU’,’ENGINEER’,’222’,’40’);
STEP8

SELECT * FROM EMP;

EMPNO ENAME JOB MGR DEPTNO

---------- ---------- ---------- ---------- ----------
111 SAKETH ANALYST 444 10
222 SUDHA CLERK 333 20
333 JAGAN MANAGER 111 10
444 MADHU ENGINEER 222 40

STEP8

EQUI JOIN

A JOIN WHICH CONTAINS AN ‘=’ OPERATOR IN THE JOINS CONDITION.

EX:

SQL> SELECT EMPNO, ENAME, JOB, DNAME,LOC FROM EMP E,DEPT D WHERE
E.DEPTNO=D.DEPTNO;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
111 SAKETH ANALYST MKT HYD
333 JAGAN MANAGER MKT HYD
222 SUDHA CLERK FIN BANG

ON CLAUSE

SQL> SELECT EMPNO, ENAME, JOB, DNAME,LOC FROM EMP E JOIN DEPT D
ON(E.DEPTNO=D.DEPTNO);

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
111 SAKETH ANALYST MKT HYD
333 JAGAN MANAGER MKT HYD
222 SUDHA CLERK FIN BANG

NON-EQUI JOIN

A JOIN WHICH CONTAINS AN OPERATOR OTHER THAN ‘=’ IN THE JOINS CONDITION.

EX:

SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP E,DEPT D WHERE E.DEPTNO >

D.DEPTNO;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
222 SUDHA CLERK MKT HYD
444 MADHU ENGINEER MKT HYD
444 MADHU ENGINEER FIN BANG
444 MADHU ENGINEER HR BOMBAY

SELF JOIN

JOINING THE TABLE ITSELF IS CALLED SELF JOIN.

EX:

SQL> SELECT E1.EMPNO,E2.ENAME,E1.JOB,E2.DEPTNO FROM EMP E1,EMP E2 WHERE

E1.EMPNO=E2.MGR;

EMPNO ENAME JOB DEPTNO

---------- ---------- ---------- ----------
111 JAGAN ANALYST 10
222 MADHU CLERK 40
333 SUDHA MANAGER 20
 444 SAKETH ENGINEER 10

CROSS / CARTESIAN PRODUCT JOIN

THIS WILL GIVES THE CROSS PRODUCT.

EX:
SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP, DEPT;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
111 SAKET ANALYST MKT HYD
111 SAKET ANALYST FIN BANG
111 SAKET ANALYST HR BOMBAY
222 SUDHA CLERK MKT HYD
222 SUDHA CLERK FIN BANG
222 SUDHA CLERK HR BOMBAY
333 JAGAN MANAGER MKT HYD
333 JAGAN MANAGER FIN BANG
333 JAGAN MANAGER HR BOMBAY
444 MADHU ENGINEER MKT HYD
444 MADHU ENGINEER FIN BANG
444 MADHU ENGINEER HR BOMBAY
NUMBER OF ROWS DISPLAYED IS 12

INNER JOIN

THIS WILL DISPLAY ALL THE RECORDS THAT HAVE MATCHED.

EX:
SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP INNER JOIN DEPT
ON EMP.DEPTNO=DEPT.DEPTNO;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
111 SAKETH ANALYST MKT HYD
333 JAGAN MANAGER MKT HYD
222 SUDHA CLERK FIN BANG

OUTER JOIN

OUTER JOIN GIVES THE NON-MATCHING RECORDS ALONG WITH MATCHING RECORDS.

LEFT OUTER JOIN

- RETRIEVS MATCHING ROWS FROM BOTH THE TABLES AND NON MATCHING ROWS FROM
THE LEFT TABLE.
- THE NON-MATCHING ROWS IN THE RIGHT TABLE WILL BE FILLED WITH NULL VALUES.

EX:

SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP LEFT OUTER JOIN DEPT

ON EMP.DEPTNO=DEPT.DEPTNO ;

OR

SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP E LEFT OUTER JOIN DEPT D

ON E.DEPTNO=D.DEPTNO;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- --------
333 JAGAN MANAGER MKT HYD
111 SAKET ANALYST MKT HYD
222 SUDHA CLERK FIN BANG
444 MADHU ENGINEER ----- -------

RIGHT OUTER JOIN

- RETRIEVS MATCHING ROWS FROM BOTH THE TABLES AND NON MATCHING ROWS FROM THE
RIGHT TABLE.
- THE NON-MATCHING ROWS IN THE LEFT TABLE WILL BE FILLED WITH NULL VALUES.
EX:

SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP E RIGHT OUTER JOIN DEPT D

ON E.DEPTNO=D.DEPTNO ;
OR

SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP LEFT OUTER JOIN DEPT

ON EMP.DEPTNO=DEPT.DEPTNO ;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
333 JAGAN MANAGER MKT HYD
111 SAKET ANALYST MKT HYD
222 SUDHA CLERK FIN BANG
----- ---------- ---------- HR BOMBAY

FULL OUTER JOIN

- MATCHING ROWS FROM BOTH THE SIDES AND NON MATCHING ROWS FROM BOTH THE
SIDES OF THE JOIN WILL BE FETCHED AND THE CORRESPONDING NON-MATCHING ROWS
WILL BE FILLED WITH NULL VALUES.

EX:

SQL> SELECT EMPNO,ENAME,JOB,DNAME,LOC FROM EMP E FULL JOIN DEPT D

ON E.DEPTNO=D.DEPTNO ;

EMPNO ENAME JOB DNAME LOC

---------- ---------- ---------- ---------- ----------
333 JAGAN MANAGER MKT HYD
111 SAKET ANALYST MKT HYD
222 SUDHA CLERK FIN BANG
----- ---------- ---------- HR BOMBAY
444 MADHU ENGINEER ---------- ----------
SQL 31 : CARTESIAN JOIN OR CROSS JOIN

A Cartesian product IS THE RESULT OF A JOIN THAT DOES NOT SPECIFY A PREDICATE

SELECT EMPIDO, EFNAME, SALARY, DEPTSFROM EMPLOYEE,DEPT;

SQL 32 : SUBQUERY

- QUERY WITHIN A QUERY

- NESTING OF ONE QUERY WITHIN ANOTHER QUERY
- STATEMENT CONTAINING SUB QUERY IS CALLED PARENT STATEMENT OR MAIN QUERY
- SUBQUERY OR INNER QUERY WILL BE EXECUTED FIRST.
- MAXIMUM NUMBER OF SUB QUERIES CAN BE 15.

EXAMPLE EMP TABLE

ENO ENAME SAL DEPT

--- ----- --- ---
101 X 5000 FIN
102 Y 20000 ADMN
103 X 10000 FIN
104 A 10000 ADMN
105 B 10000 ACCT
106 C 15000 FIN

SELECT * FROM EMP WHERE SAL>=(SELECT MAX(SAL) FROM EMP)

SELECT * FROM EMP WHERE SAL >= (SELECT SAL FROM EMP WHERE ENO=’104’);

SELECT * FROM EMP WHERE SAL = (SELECT MAX(SAL) FROM EMP WHERE SAL < (SELECT
MAX(SAL) FROM EMP))

EXIST QUALIFIER
---------------

- SUBQUERY EVALUATED TO TRUE OR FALSE BASED ON CONDITION GIVEN

- RETRIEVES DATA WHEN SUBQUERY EVALUATED TRUE

SELECT * FROM EMP WHERE EXISTS ( SELECT * FROM BANK WHERE NAME LIKE 'R%')

NON EXIST QUALIFIER

---------------------------------
- RETRIEVES DATA WHEN SUBQUERY EVALUATED FALSE

SELECT * FROM EMP WHERE NOT EXISTS( SELECT * FROM BANK WHERE NAME LIKE 'R%')

SQL 34 : UNION & UNION ALL

- The UNION operator is used to combine the result-set of two or more SELECT
statements.
  Each SELECT statement within UNION must have the same number of columns
 The columns must also have similar data types
 The columns in each SELECT statement must also be in the same order
 MAXIMUM OF 15 TABLES CAN BE JOINED
 Though the column names can be different like NAME & ENAME their data
type should be compatible.

UNION
-----
- ELIMINATE DUPLICATES
- TO MERGE THE ROWS
- OUTPUT IN ASCENDING ORDER

SELECT City FROM Customers

UNION
SELECT City FROM Suppliers
ORDER BY City;

SELECT ENO FROM EMP1 UNION ALL SELECT ENO FROM EMP2

SELECT * FROM EMP1 UNION SELECT * FROM EMP2

UNION ALL
-----------------
- RETRIEVES ALL THE VALUES INCLUDING DUPLICATES

SELECT NAME FROM EMP1 UNION ALL SELECT ENAME FROM EMP2;

SELECT City FROM Customers

UNION ALL
SELECT City FROM Suppliers
ORDER BY City;

SELECT City, Country FROM Customers

WHERE Country='Germany'
UNION
SELECT City, Country FROM Suppliers
WHERE Country='Germany'
ORDER BY City;

SQL 34 : CREATING VIEW

VIEWS
-----
- VIEW IS A VIRTUAL TABLE
- VIEW IS NOT AN AUTONOMOUS TABLE, IT IS DEFINED IN TERMS OF OTHER BASE TABLES.

ADVANTAGE
---------
- IT IS NOT PHYSICALLY STORED IN DATABASE AND HENCE IT WILL NOT OCCUPY ANY SPACE
- IT CAN BE CREATED BY TAKING SUBSET OF ROWS AND COLUMNS FROM BASE TABLE
- IT CAN BE CREATED BY TAKING INFORMATION FROM MULTIPLE TABLES THROUGH JOINS
- THE COLUMN NAME CAN BE CHANGED IN A VIEW AND IT WILL NOT AFFECT THE INFORMATION
 IN A BASE TABLE.
- VIEWS ARE LIKE WINDOW PRESENTATION OF A BASE TABLE, SO CHANGES IN BASE TABLE
WILL BE REFLECTED IN VIEWS & VICEVERSA.
- IT IS CALLED AS STORED QUERY BECAUSE THE SQL QUERY WHILE CREATING A VIEW WILL NOT
BE EXECUTED AND IT WILL BE SIMPLY STORED IN CATALOG TABLE SYSVIEWS.

CREATE VIEW V1 AS SELECT * FROM EMPLOYEE;

SELECT * FROM V1;

NOTE
- IF THE BASE TABLE IS DROPPED, VIEW IS ALSO DROPPED.
- VIEW CAN BE CREATED BY TAKING INFORAMTION FROM ANOTHER VIEW
- ALTERING THE STRUCTURE OF BASE TABLE WILL NOT AFFECT THE STRUCTURE OF THE VIEW

CREATE VIEW EMPVIEW(A1,B1,C1)

AS SELECT * FROM EMPLOYEE ;

SELECT * FROM EMPVIEW;

DISPLAY DETAILS IN VIEW

SELECT * FROM EMPVIEW;

-----+---------+---------+---------+---------+---------+---------+-----
EMPID EFNAME ELNAME EMPDOB EMPSAL EMPDEPT
-----+---------+---------+---------+---------+---------+---------+-----
A0001 JAIKUM PRADEEP 1977-07-25 7000.00 D0001
A0003 PRIYA PV 1988-10-02 6000.00 D0002
B0001 ANURAG GN 1997-07-05 12000.00 D0003
B0004 ABHILASH GN 1900-12-05 10000.00 D0001
E0001 PRADEEP PV 1999-11-05 15000.00 D0001
E0003 SEEMA ROY 1977-08-30 8000.00 D0005

CREATE VIEW EMPVIEW(EMPID,EFNAME,ELNAME,EMPDOB,EMPSAL,EMPDEPT)

AS SELECT * FROM EMPLOYEE WHERE EMPSAL > 5000;

EXAMPLES
-----------------
CREATE VIEW V1 AS SELECT * FROM EMPLOYEE;

CREATE VIEW V2 AS SELECT ENO FROM EMPLOYEE WHERE EMPSAL>10000;

CREATE VIEW V3 AS SELECT * FROM EMPLOYEE WHERE EMPSAL < 2000 WITH CHECK
OPTION;

CREATE VIEW V4 AS SELECT * FROM V1 WHERE EMPSAL > 6000;

NOT UPDATABLE VIEWS

-----------
- VIEWS CREATED USING DISTINCT CLAUSE
- VIEWS CREATED USING GROUP FUNCTIONS
- VIEWS CREATED USING GROUP BY CLAUSE
- VIEWS CREATED USING HAVING CLAUSE
- VIEWS CREATED USING SUBQUERIES
- VIEWS CREATED USING JOINS
- VIEWS CREATED FROM MULTIPLE TABLES
UPDATABLE VIEWS
-------
- ROW COLUMN EXTRACTED FROM A SINGLE TABLE

SQL 35 : GRANT & REVOKE

GRANT ALL ON EMPDEPT TO PUBLIC;

GRANT SELECT ON EMPDEPT TO LEMA02;

GRANT SELECT, UPDATE(EMPNM, EMPSAL) ON EMP TO LEMA02;

GRANT INSERT ON EMPLOYEE TO LEMA02 WITH GRANT OPTION;

REVOKE SELECT ON EMP FROM LEMA02;

REVOKE ALL ON DEPT FROM LEMA02;

SQL 36 : SELECTING FROM DB2-CATALOG

1. SELECT * FROM SYSIBM.SYSTABLES WHERE CREATOR='LEMA01'

2. SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBNAME='EMPLOYEE';

3. SELECT COLNO,COLTYPE,LENGTH FROM SYSIBM.SYSCOLUMNS WHERE TBNAME='EMPLOYEE'

4. SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBCREATOR ='LEMA01' AND TBNAME

='EMPLOYEE';

5. SELECT * FROM SYSIBM.SYSFOREIGNKEYS WHERE TBNAME='EMPLOYEE' AND

CREATOR='ADMIN01';

6. SELECT * FROM SYSIBM.SYSINDEXES WHERE CREATOR='ADMIN01' AND

TBNAME='EMPLOYEE';

7. SELECT * FROM SYSIBM.SYSVIEWS WHERE CREATOR='ADMIN01';

8. SELECT * FROM SYSIBM.SYSSYNONYMS WHERE CREATOR = 'ADMIN01';

9. SELECT DAY(CURRENT DATE) FROM SYSIBM.SYSDUMMY1; 25

10. SELECT DATE(CURRENT DATE) FROM SYSIBM.SYSDUMMY1; 2005-03-25

11. SELECT TIME(CURRENT TIMESTAMP) FROM SYSIBM.SYSDUMMY1;

12. SELECT DATE(CURRENT TIMESTAMP) FROM SYSIBM.SYSDUMMY1;

13. SELECT CURRENT DATE FROM SYSIBM.SYSDUMMY1 - 2005-03-25

14. SELECT CURRENT TIME FROM SYSIBM.SYSDUMMY1 - 11.09.30

15. SELECT CURRENT TIMESTAMP FROM SYSIBM.SYSDUMMY1 -

2005-03-25-11.09.30.850985

16. SELECT CURRENT TIME FROM SYSIBM.SYSDUMMY1;

17. SELECT DATE('5/31/1988') + 1 MONTH FROM SYSIBM.SYSDUMMY1;

18. SELECT DATE('5/31/1988') + 1 MONTH - 1 MONTH FROM SYSIBM.SYSDUMMY1;

19. SELECT DATE('5/31/1988') + 30 DAYS - 30 DAYS FROM SYSIBM.SYSDUMMY1;

SQL : 38 DROPING TABLE / VIEW / INDEX

DROP TABLE EMP;

DROP INDEX EMPIDX;

DROP VIEW VIEWNAM;

DROP ALIAS AS1 ;

DROP SYNONYM SN1

Drop Constraints:

Constraints defined on a table can be dropped with the help of alter table
command with Drop Constraint keyword.

Syntax: ALTER TABLE <Table Name> DROP CONSTRAINT <Constraint

Name>

e.g. ALTER TABLE EMPLOYEE DROP CONSTRAINT CDID

SQL : 39 RENAMING TABLE

RENAME TABLE EMPLOYEE TO NEW_EMPLOYEE;

SQL : 39 RENAMING A COLUMN

The RENAME COLUMN clause is a new option on the ALTER TABLE statement.

You can rename an existing column in a base table to a new name without
losing stored data

ALTER TABLE <tabname> RENAME COLUMN <column_name> TO <new_column_name>

SQL : 40 ALTERING TABLE

ALTER TABLE EMPLOYEE ADD BONUS DECIMAL(6,2);

ALTER TABLE EMPLOYEE ALTER ELNAME SET DATA TYPE VARCHAR(30);

ALTER TABLE EMPLOYEE DROP PRIMARY KEY;

ALTER TABLE EMPLOYEE ADD PRIMARY KEY (EMPNO);

ALTER TABLE EMP ADD AAA CHAR(4);

NOTE:
ADDS A NEW COLUMN WITH NULL VALUES, BUT
ALTER TABLE EMP ADD AAA CHAR(4) NOT NULL IS NOT ALLOWED .
TO OVERCOME TRY NEXT COMMAND WITH DEFALUT VALUES.

ALTER TABLE EMP ADD PHONE VARCHAR(10) NOT NULL WITH DEFAULT ;

SQL : 41 SYNONYMS

SYNONYM
-------

- ALTERNATE NAME FOR A TABLE OR VIEW

- PRIVATE TO THE USER WHO CREATED IT
- INFORMATION ABOUT SYNONYMS ARE STORED IN SYSIBM.SYSSYNONYMS

SYNTAX

- CREATE SYNONYM <SYNONYM NAME>FOR USERID.TABLENAME / VIEWNAME

CREATE SYNONYM S1 FOR EMPLOYEE;

CREATE SYNONYM S2 FOR V1;

SQL : 42 ALIAS

ALIAS
-----
- ALTERNATE NAME FOR A TABLE OR VIEW
- PUBLIC TO ALL USERS
- GLOBAL OBJECT
- IF BASE TABLE IS DROPPED, ALIAS WILL NOT BE DROPPED
- ALIAS CAN BE CREATED WITHOUT THE BASE TABLE

SYNTAX

- CREATE ALIAS <ALIAS NAME> FOR USERID.TABLENAME/VIEWNAME

CREATE ALIAS AA FOR EMPLOYEE;

SQL 43:COMMIT/ ROLLBACK.

COMMIT
-------------
- IT IS USED TO SAVE THE TRANSACTION
- IT IS USED TO MAKE ALL THE CHANGES PERMANENTLY IN A DATABASE

COMMIT;

ROLLBACK
------------------
- IT IS USED TO UNDO ALL THE CHANGES MADE IN THE PRESENT TRANSACTION
ROLLBACK;

******************* END **************************************

DB2 – 10 DETAILS

1. Table Name 30 characters( now 128 characters) Column name (18

characters ( now 30 characters)
2. Cursor Name – 30
3. Database Name – 8
4. Plan Name – 8
5. Package name - 8
6. Table Space name – 8
7. PGM Name – 8
8. Maximm Sub query in one statement – 224
9. Char – 255
10. VARCHAR – 4046
11. Maximum Column in one Table – 750
12. Maximum number of records can be inserted in one INSERT is 32767
13. Partition – 64
14. SQLCA – 136
15. SQLCODE – PIC S9(9) COMP-4
16.

------SCROLLABLE CURSOR DETAILS-----

Direction Detail
option
Positions the cursor on the next row and read that row.
NEXT This is the default if no position is specified.

Positions the cursor on the previous row and read that row
PRIOR
Positions the cursor on the first row and read that row
FIRST
Positions the cursor on the last row and read that row
LAST
Positions the cursor before the first row.[No data is read
BEFORE in this case]

Positions the cursor after the last row.[No data is read in

AFTER this case]

Read the current row but does not change the cursor
CURRENT
position.

Evaluates (a host variable or integer) n in relationship

tothe cursor’s current position.
RELATIVE n For example,ifn is -1,the cursor is positioned on the
previous row of the result table.
If n is +3,the cursor is positioned three rows after the
current row.
ABSOLUTE n If n is ZERO : CURSOR will be positioned before the
FIRST row of result table.
 Direction Detail
option
Ifn is positive : CURSOR will be positioned on nthrecord of
result table from TOP.
n = 3 : CURSOR will be positioned on 3rdrecord of result
table from TOP

If n is negative : CURSOR will be positioned on

(last+nth+1)record of result table from BOTTOM.
Let say result table has total 10 record.So
n= -1 : CURSOR will be positioned on LAST Record
[(10-1+1) = 10]

n= -3 : CURSOR will be positioned on 8th Record

[(10-3+1) = 8]

===============================================================