Mangala Deshpande MySQL0710.ppt

Introduction:
• MySQL is a DBMS (DataBase
Management System) i.e. it is a databse
software.
• MySQL is 5.0 can be downloaded from the
website http://dev.mysql.com/downloads.
• MySQL runs on all major platforms such
as Windows, Linux, Solaris, Mac OSX etc.

• What is SQL?
Full form of SQL is Structured Query
Language. SQL is a language designed for
communicating with the databases. It is a
basic tool for accessing data in a relational
database.

• SQL is made up of very few words. It
provides a simple and efficient way to read
and write the data from a database.
• SQL is not a proprietary language of any
DBMS. Learning this one language
enables us to interact with any DBMS.
• SQL is easy to learn. With the help of
SQL we can perform very complex
database operations.

• MySQL is client-server-based databases.
Client server applications are split into two
parts. The server portion is a piece of
software that is responsible for data
access and manipulation.
• Client is the piece of software with which
the user interacts.
• To use MySQL we need a client, an
application that you use to interact with
MySQL(to give commands to be executed)

• There are three tools used as client
application
• MySQL command line utility
• MySQL Query Browser
• MySQL Administrator.
• ( MySQL command line utility is a part of
core MySQL installation, whereas MySQL
Query Browser and MySQL Administrator
come under GUI tools of MySQL)

• Database:
• Database is collection of data stored in
some organized fashion. We can consider
it to be similar to a filing cabinet.
• We have files in the filing cabinet and
related data is stored in specific files. A file
is called as a table in DBMS.
• Hence a database is container of number
of tables.

• Relational Database:
When information can be presented in the
form of tables in a database, regardless of
how it is stored, the arrangement of data is
called as relational database. The term
relational database comes from the fact that
data columns are related to each other by
virtue of their values.

• Every table in a database has a unique
name that identifies it. That means no
other table in that database can have the
same name.
• The database name and the table name
together make the table name unique.
This means one can not use the same
table name in the same database but one
can reuse the table names in different
databases.

• Tables are made up of columns. A column
contains a particular piece of information.
For e.g. in a table called CUST we can
have a column containing customer name,
customer address etc.
• Each column in a table has an associated
datatype. A datatype defines what type of
data a column can contain.

• We will mainly use the following
datatypes
1. Numeric Datatype: Numeric datatypes
store numbers. We will following two
datatypes to store numbers.
INT: This datatype stores integer values and
supports numbers from -2147483648 to
2147483647.
DECIMAL(or DEC): It stores floating point
values with varying levels of precision.

• SMALLINT: Stores integer value,
supports numbers from -32768 to 32767
(or 0 to 65535 if UNSIGNED)
• BIGINT: Stores integer value supports
numbers from -9223372036854775808 to
9223372036854775807
(or 0 to 18446744073709551615 if
UNSIGNED)

• TINYINT: Stores integer value from -128 to
127 (or 0 to 255 if unsigned).
• BOOLEAN ( or BOOL): This data type is
used to store value 0 or 1. BOOLEAN
data type is converted into TINYINT.

• DECIMAL(or DEC): It stores floating point
values with varying levels of precision. It can
store maximum of 65 digits and supports up to
30 decimals.
• FLOAT: Stores small four byte single-precision
floating point values. Precision of floating point
number is between 0 to 24.
• DOUBLE: Stores normal eight byte double-
precision floating point values. Precision is
between 25 to 53.

2. Date and Time datatypes
• DATE: Date from 1000-01-01 to 9999-12-31 in
the format YYYY-MM-DD.
• TIME: Time from -838:59:59 to 838:59:59 in
the format HH:MM:SS
• DATETIME: A combination of DATE and TIME
in the format YYYY-MM-DD HH:MM:SS. This
type does not have automatic update features
as TIMESTAMP.

• TIMESTAMP: Equivalent to DATETIME but with
a smaller range. Range is 1970-01-01 00:00:00
to sometime in 2037. TIMESTAMP is
automatically updated to current date and time
when a new row is inserted or updated.
• YEAR: A 2 or 4 digit year 2 digit year supports a
range of 70(1970) to 69(2069), 4 digit year
support a range of 1901 to 2155.

3. String datatypes:
• CHAR: Fixed length string from 1 to 255
characters long. Its size must be
specified at the time of creating a table.
If the length is not specified then MySQL
assumes it to be 1.
• VARCHAR: Same as CHAR but stores
text of variable size length. Maximum
value of width is 65,535 characters.

TEXT : Variable length text with maximum
size of 64K
MEDIUMTEXT: Same as TEXT but with
maximum size of 16K.
LONGTEXT: Same as TEXT but with a
maximum size of 4GB.

• Fixed length string are datatypes that are
defined to accept a fixed number of
characters. It will not accept more than the
specified number of characters. Fixed
length string i.e. CHAR can contain 1 to
255 characters.
• MySQL can sort and manipulate fixed
length datatypes more quickly than
variable length.

• Data in a table is stored in rows. Every row
in a table should have a column(or
columns) that uniquely identifies it. This
column is called as the primary key.
• For e.g. a table called CUST may have
cust_id (unique numeric customer ID) as
the primary key.

• Any column can be defined as the primary
key as long as it satisfies the following
conditions.
• No two rows can have same primary key
value.
• Every row must have a primary key value.
(Primary key columns will not allow NULL
values.)

Generally we have one primary key
column for a table. But we may use
multiple columns together as primary key.
The rules defined for a primary key column
must apply to columns that make up the
primary key

• Foreign Key: A column in one table that
contains primary key values from another
table is called as the foreign key. It defines
relationship between two tables.
• For e.g. In BILL table CUST_ID can be
used as the foreign key, CUST_ID is
primary key in CUST table.

• We need a default database to work with.
We can create a new database with help
of command
• CREATE DATABASE
Or
• CREATE SCHEMA
• The keywords in the commands are not
case sensitive.
• For e.g. CREATE DATABASE SHOP;

• List of databases can be seen with the
help of command
SHOW DATABASES;
• List of tables within a database can be
obtained with the help of statement
SHOW TABLES FROM SHOP;
• To use a database called SHOP we give
the command
USE SHOP;

• To create a table called CUST following
set of SQL statements is used.
CREATE TABLE CUST
(CUST_ID INT NOT NULL,
NAME CHAR(20) NOT NULL,
CITY CHAR(20) NOT NULL,
PHONE CHAR(20) NULL,
PRIMARY KEY (CUST_ID));

• To create a table called BILL following set
of SQL statements is used.
CREATE TABLE BILL
BILLNO INT NOT NULL
AUTO_INCREMENT,
AMT DECIMAL(10,2) NOT NULL,
PRIMARY KEY(BILLNO));

• Only one auto_increment column will be
allowed per table and it must be made
primary key.
• If we want to use a specific value for
auto_increment column then it can be
entered using INSERT statement. This
value will be accepted as long as it is
unique. Subsequent incrementing will start
using the value manually inserted.

• The column name can not contain any comma
or blank spaces or any other special symbol
(except $ and _).
• Column name can be up to 64 characters long.
Digits from 0 to 9 will be allowed within a column
name.
• Keywords can not be used as column names.
Column name may begin with a digit or $. Same
rules are applicable to the table names. Column
names and table names are case insensitive.

• We can create BILL table by defining
foreign key as follows
CREATE TABLE BILL
BILLNO INT NOT NULL AUTO_INCREMENT,
AMT DECIMAL(10,2) NOT NULL,
PRIMARY KEY(BILLNO),
FOREIGN KEY (CUST_ID) REFERENCES
CUST (CUST_ID));

• The two tables CUST and BILL will be
stored in the database SHOP.
• To see the list of columns from table CUST
we use the command
SHOW COLUMNS FROM CUST;
Columns CUST_ID and NAME in CUST
must not be empty as NOT NULL is
specified, whereas address and phone
columns may not be filled.

• We may use any name to store CUST_ID in the
table BILL and still define it as foreign key.
• For e.g. if we use CNO instead of CUST_ID in
BILL then we define foreign key statement as
• FOREIGN KEY (CNO) REFERENCES CUST
(CUST_ID));
• SHOW COLUMNS FROM BILL;
displays columns as

Field Type Null Key Default Extra
CUST_ID int(11) NO MUL
BILLNO int(11) NO PRI auto_increment
AMT decimal(10,2) NO

• MUL against column CUST_ID means that
multiple occurrences in this column will be
allowed.
If foreign key is defined then we can not
delete or update column CUST_ID in CUST
table.

• To look at the code used for creating a
table CUST, we use statement
SHOW CREATE TABLE CUST;
MySQL server status information can be
seen with the help of command
SHOW STATUS;

• MySQL enables us to specify default
values to be used if no values are
specified when a row is inserted. Default
values are specified using the DEFAULT
keyword in the column definition in the
CREATE TABLE statement. For e.g.

CREATE TABLE EMP
(EMP_ID INT NOT NULL,
NAME CHAR(20) NOT NULL,
DEPTID CHAR(10) NOT NULL,
DOJ DATE NOT NULL,
CITY CHAR(10) NOT NULL,
PERM BOOL NOT NULL DEFAULT 1,
PRIMARY KEY (EMP_ID));

BOOLEAN data type is usually taken as
TINYINT. Value 1 is true and 0 is false.
The order of NOT NULL and DEFAULT can
be interchanged.

• We may use DESCRIBE as shortcut for
SHOW COLUMNS FROM
For e.g.
DESCRIBE CUST;

• To add data to the columns in the table
CUST we use the command INSERT as
follows.
• INSERT INTO CUST
VALUES
('1',
'ANAND',
'MUMBAI',
NULL);

• It is important to note that values must be
inserted in the order as the order of
columns specified in the table CUST. One
may write an entire SQL statement in a
single line.

• One can use INSERT command by
changing order of the columns in the table.
Order in which values are to be inserted
must be specified. Also one can omit some
of the columns provided the columns are
defined to contain NULL values or some
default values.
• For e.g.
INSERT INTO CUST
(NAME,CUST_ID,CITY)
VALUES('BEENA',3, 'PUNE');

We may insert values in a table without
specifying the auto increment value.
For e.g. In BILL table BILLNO is an auto
increment column. To generate the next
BILLNO we specify the other column names
and their values in INSERT statement as
follows.
INSERT INTO BILL(CUST_ID,AMT)
VALUES (4,4000);

• We can insert two or more in a table by
using a single INSERT statement
For e.g. we insert two rows in BILL table
as follows
INSERT INTO BILL (CUST_ID,AMT)
VALUES(3,5000),
(5,9000);

• ALTER STATEMENT:
ALTER statement is used to change the
structure of a table after it has been created.
ALTER statement is used to add columns or
to delete columns from the table. Also it is
used to change type and width of the
columns and to rename the columns.

For e.g.
ALTER TABLE BILL
ADD DT_PUR DATE NULL;
A new column with name DT_PUR will be
added to the table BILL.
ALTER TABLE CUST
ADD GENDER CHAR(1) NOT NULL;

• To drop the column DT_PUR we can give
the command
ALTER TABLE BILL
DROP COLUMN DT_PUR ;
The keyword COLUMN in above two
statements is optional.

We can rename a column using ALTER
statement
e.g.
ALTER TABLE CUST CHANGE COLUMN
PHONE CPHONE CHAR(20) NOT NULL ;
ALTER TABLE CUST CHANGE COLUMN
CPHONE PHONE CHAR(10) NOT NULL;
Column name, its type and width can all be
changed in a single statement.

It is advisable not to change data type as we
may lose data.(It is advisable to specify null
or not null in column definition). Keyword
COLUMN is optional.
To make AMT column in BILL table contain
default value as 0 we use ALTER statement as
follows.
ALTER TABLE BILL CHANGE
COLUMN AMT AMT DEC(10,2) NOT NULL
DEFAULT 0;

• We can make alterations to two or more
columns at a time using ALTER TABLE
statement for e.g.
• ALTER TABLE CUST DROP GENDER,
ADD PIN CHAR(10) NULL;
• ALTER TABLE CUST CHANGE NAME
CNAME CHAR(20) NOT NULL, CHANGE
CPHONE PHONE CHAR(10) NULL;

We can rename a table using RENAME
statement
For e.g.
RENAME TABLE CUST TO CUST1;

• To see the contents of all the columns
from table CUST give command
• SELECT * FROM CUST;
or
• SELECT * FROM SHOP.CUST;
• To display contents of specific columns
give command
• SELECT CUST_ID,NAME,CITY FROM
CUST;

CUST_ID NAME CITY
1 BEENA MUMBAI
2 GEETA NAGPUR
3 ANAND PUNE
4 ATUL MUMBAI
5 RAHUL MUMBAI
6 LATA PUNE
7 AJAY MUMBAI
9 DEEPA MUMBAI

• SELECT CUST.NAME FROM
SHOP.CUST;
• To return first few rows we use LIMIT
clause for e.g.
• SELECT * FROM CUST LIMIT 5;
It will display the first five rows of table
CUST
• SELECT * FROM CUST LIMIT 5,4;
• It will display rows from 6 to 9 of table
CUST.

• DISTINCT:
• To get distinct CUST_ID values from table
BILL we use statement
• SELECT DISTINCT CUST_ID FROM
BILL;
• If DISTINCT is not specified then all the
rows will be retrieved. That means ALL is
the default value.

• ORDER BY
Data in a table can be sorted in ascending
or descending order with help of clause
ORDER BY
For e.g.
SELECT * FROM CUST ORDER BY NAME;
SELECT * FROM CUST ORDER BY NAME
DESC;

• Sorting can be done on multiple fields for
e.g.
• SELECT * FROM CUST ORDER BY
CITY,NAME;
• SELECT * FROM CUST ORDER BY CITY
DESC, NAME;
• SELECT * FROM CUST ORDER BY
CITY,NAME DESC;

We can combine ORDER BY and LIMIT
clause
SELECT * FROM CUST
ORDER BY CITY LIMIT 4;
SELECT * FROM CUST
ORDER BY CITY LIMIT 2,3;

• WHERE clause: WHERE clause is used
to retrieve those rows which match the
specified condition.
• SELECT * FROM CUST WHERE
CITY='MUMBAI' AND CUST_ID<=3;
CITY='MUMBAI' OR CUST_ID<=3;
• SELECT * FROM BILL WHERE
AMT>=5000;

• SELECT DISTINCT CUST_ID FROM BILL
WHERE AMT>10000;
CUST_ID
1
2
3
4
7

• SELECT CUST_ID,AMT FROM BILL
WHERE AMT>10000 ORDER BY
CUST_ID;
CUST_ID AMT
1 11000
2 11000
3 16000
3 11000
4 16000
7 11000

CUST WHERE CITY<>'MUMBAI';
CUST WHERE CITY!='MUMBAI';
NAME<='G' ORDER BY NAME;
NAME>'G' ORDER BY NAME;

• LIKE operator:
• SELECT * FROM CUST WHERE NAME LIKE
'A%';
The above command gives list of all rows for which
NAME begins with letter A
• SELECT * FROM CUST WHERE NAME LIKE
'a%';
• The above command gives list of all rows for
which NAME begins with letter a.

• SELECT * FROM CUST WHERE NAME
LIKE '%A%';
• The above command gives list of all rows
for which NAME contains letter A.
• One can combine LIKE operator and
ORDER BY clause.
e.g.
• SELECT * FROM CUST WHERE CITY
LIKE 'D%' ORDER BY NAME;

• We can combine LIKE operator and AND
operator for e.g.
• SELECT * FROM CUST WHERE CNAME
LIKE '%A%' AND CITY='MUMBAI';

CITY='MUMBAI' ORDER BY NAME;
• SELECT * FROM BILL WHERE DT_PUR
BETWEEN '2000-05-05' AND '2002-09-
09';
The above statement is equivalent to
SELECT * FROM BILL
WHERE DT_PUR >='2000-05-05' AND
DT_PUR <='2002-09-09';
• Date must be enclosed in quotes.

• SELECT BILLNO, AMT FROM BILL
WHERE AMT BETWEEN 5000 AND 7000;
The above statement is equivalent to
SELECT BILLNO, AMT FROM BILL
WHERE AMT>=5000 AND AMT<=7000;

• IN operator:
• IN is a keyword used in WHERE clause to
specify a list of values to be matched
using an OR comparison.
e.g. SELECT CUST_ID, NAME
FROM CUST WHERE CUST_ID IN
(2,4) ORDER BY NAME;
• It returns CUST_ID and NAME for those
rows for which CUST_ID has value 2 OR
4 in alphabetical order of NAME.

• Same task can be accomplished with help
of OR operator as follows
SELECT CUST_ID, NAME
FROM CUST WHERE CUST_ID =2 OR
CUST_ID=4 ORDER BY NAME;
SELECT CUST_ID,NAME,CITY FROM
CUST WHERE CITY IN ('MUMBAI','PUNE');

• NOT operator: It is used to negate a
condition. e.g.
FROM CUST WHERE CUST_ID NOT IN
(2,4) ORDER BY NAME;
• It returns CUST_ID and NAME for all
those rows for which CUST_ID is other
than 2 or 4.

• This task can also be accomplished with
the help of AND operator as follows
FROM CUST WHERE CUST_ID !=2 AND
CUST_ID!=4 ORDER BY NAME;
SELECT CUST_ID,CNAME,CITY FROM
CUST WHERE CITY NOT IN
('MUMBAI','NAGPUR') ORDER BY NAME;

Another example of IN operator
CUST_ID IN (2,3,4);
CUST_ID NOT IN (2,3,4);

• UPDATE statement:
• To modify data in a table UPDATE
statement is used.
It can be used in two ways.
1. To update specific rows in a table.
2. To update all the rows in a table.

• Basic format of UPDATE statement
consists of three parts.
1. The table to be updated
2. The column names and their new values
3. The condition which determines which rows
to be updated.

• To update specific rows in a table we
WHERE clause
• For e.g.
(i) UPDATE BILL
SET DT_PUR ='2007-05-05' WHERE
BILLNO=237;
(ii) UPDATE CUST
SET CITY='MUMBAI',
PHONE='4567889' WHERE CUST_ID=5;

• If we omit the WHERE clause in UPDATE
statement then every row in the table gets
updated with the new values.
UPDATE CUST SET CITY='MUMBAI';
For every row ADDRESS gets updated as
MUMBAI.
UPDATE BILL SET AMT=AMT+1000;
Each amt will be increased by 1000.

• DELETE statement:
• DELETE is used to
1. To delete specific rows from a table
2. To delete all rows from a table

• For e.g.
• DELETE FROM CUST
WHERE CUST_ID=5;
• DELETE FROM BILL WHERE
AMT>=5000;
• If we execute DELETE statement without
WHERE clause then all the contents of a
table get deleted.

• We can use ORDER BY and LIMIT clause
along with DELETE statement as follows
DELETE FROM BILL ORDER BY CUST_ID
LIMIT 5;
It deletes first 5 rows from the BILL table
after arranging the table in ascending order
of CUST_ID.

• DROP statement:
It is used to delete entire table.
e.g. DROP TABLE CUST;
This statement deletes table CUST. There is
no confirmation nor there is an undo.
• It can also be used to delete entire
database
• e.g. DROP DATABASE SHOP;

• Aggregate functions:
• Aggregate functions are used to
summarize the data without actually
retrieving it.
• AVG(): It returns average value of a
column.

• COUNT() : It returns number of rows in a
column.
• MAX() and MIN() return the maximum and
minimum values of a column.
• SUM() returns total for a column.

• GROUP BY clause:
• The GROUP BY clause is used to sort the
data into groups for the purpose of
aggregation.
• Suppose we want the number of times
each customer has purchased from the
shop then for this we use GROUP BY
clause as follows

SELECT CUST_ID,COUNT(*)
FROM BILL GROUP BY CUST_ID;
SELECT AVG(AMT) FROM BILL
GROUP BY CUST_ID;

• SELECT CUST_ID,SUM(AMT) FROM
BILL GROUP BY CUST_ID;
• SELECT CUST_ID, COUNT(*),SUM(AMT)
FROM BILL WHERE AMT>=10000
GROUP BY CUST_ID ORDER BY
CUST_ID DESC;

CUST_ID COUNT(*) SUM(AMT)
7 1 11000
6 1 12000
5 2 20000
4 1 16000
3 2 27000
2 2 21000
1 1 11000

• SELECT CUST_ID, MAX(AMT) FROM
BILL WHERE
AMT>=10000 AND AMT<=15000
CUST_ID DESC;
• SELECT CUST_ID, MIN(AMT) FROM
BILL WHERE
DT_PUR>= '2009-01-01'
CUST_ID DESC;

• A column name can be called by some
other name called as column alias. e.g.
• SELECT * , .10*AMT AS DISCOUNT
FROM BILL;
• SELECT * , AMT-.10*AMT AS NSP FROM
BILL;
• Keyword AS is optional.

MySQL functions:
CONCAT() function is used to combine two
or more strings.
SELECT
CONCAT(NAME , 'STAYS IN' ,CITY);

SELECT
CONCAT(TRIM(' MONDAY '),' 'TUESDAY');
SELECT
CONCAT(RTRIM(' MONDAY '),' ','TUESDAY');
SELECT
CONCAT(LTRIM(' MONDAY '),' ','TUESDAY');
SELECT MID('COMPUTER',4,3);
SELECT SUBSTRING('COMPUTER',4,3);

• SELECT RIGHT(CNAME,3) FROM CUST;
Returns 3 rightmost characters from
CNAME
SELECT LEFT(CNAME,3) FROM CUST;
Returns 3 leftmost characters from CNAME
• SELECT UPPER(CNAME) FROM CUST;
Returns CNAME in uppercase letters. We
may use UCASE instead of UPPER.

SELECT LOWER(CNAME) FROM CUST;
Returns CNAME in lowercase letters. We
may use LCASE instead of LOWER.
LENGTH()
This function returns the number of
characters contained in the given string.
SELECT LENGTH('COMPUTER');

SELECT NOW();
Returns the current date and time.
SELECT TIME(NOW());
Returns the current time.
SELECT TIME('2009-12-14 19:30:00');
Returns the time. i.e. 19:30:00
SELECT CURDATE();
Returns the current date.

SELECT DATE('2009-09-14 19:30:00');
Returns the date i.e. 2009-09-14
SELECT DAY('2009-09-14 19:30:00');
Returns day value i.e. 14
SELECT DAYNAME('2009-09-25 19:30:00');
Returns day name Friday

• MONTH()
Returns month from given date
SELECT MONTH('2009-09-10');
MONTHNAME()
Returns name of the month from given date
SELECT MONTHNAME('2009-09-10');
YEAR()
Returns year from given date
SELECT YEAR('2009-09-10');

SELECT MONTH('2009-12-14 19:30:00');
Returns month 12
SELECT MONTHNAME('2009-12-14 9:30:00');
Returns December
SELECT YEAR('2009-12-14 19:30:00');
Returns year i.e. 2009.
ABS()
Returns absolute value of the given number.
SELECT ABS(-10);

POW() or POWER()
Returns a number raised to a power.
SELECT POW(3,2);
MOD()
Returns remainder after dividing first number
by the second
SELECT MOD(5,4);

ROUND()
It rounds off the number to specified number of
decimal places.
SELECT ROUND(123.5678,2);
SQRT()
Returns square root of a positive number
SELECT SQRT(9);
EXP()
Returns e raised to specified power.
SELECT EXP(2);

• HAVING clause:
• HAVING clause is used to add additional control
to the aggregation of rows in a GROUP BY
operation.
• Suppose we want list of all those customers who
have purchased at least twice from the shop we
use HAVING clause as follows
• SELECT CUST_ID, COUNT(*) FROM BILL
GROUP BY CUST_ID HAVING COUNT(*)>=2;

• A WHERE clause does not work here as
filtering is done based on groups and not
based on individual rows.
• SELECT CUST_ID,SUM(AMT) FROM
BILL GROUP BY CUST_ID HAVING
SUM(AMT)>=10000 ORDER BY
CUST_ID;

CUST_ID SUM(AMT)
1 11000
2 26000
3 36000
4 25000
5 20000
6 12000
7 16000

• SELECT CUST_ID,MAX(AMT) FROM BILL
GROUP BY CUST_ID
HAVING SUM(AMT)>=15000 AND
SUM(AMT)<=50000 ORDER BY CUST_ID;
• SELECT CUST_ID,COUNT(*),SUM(AMT)
FROM BILL WHERE DT_PUR>='2009-01-01'
GROUP BY CUST_ID HAVING
SUM(AMT)>=10000 ORDER BY CUST_ID;

1 1 11000
3 2 20000
4 2 25000
6 1 12000

• SELECT CUST_ID,COUNT(*),SUM(AMT)
FROM BILL
WHERE DT_PUR>='2009-01-01'
SUM(AMT)>=10000 ORDER BY
SUM(AMT);

1 1 11000
6 1 12000
3 2 20000
4 2 25000

• JOIN:
• Relational Tables:
• The two tables discussed so far are
relational tables. Table CUST contains
information about customers visiting a
shop such as customer name, address
etc. Customer identity (CUST_ID) is the
primary key.

• Another table BILL contains information
regarding details about bill amount, date of
purchase, bill number (bill number forms
the primary key as this table contains
multiple entries). The two tables can be
related to each other through a common
value which is CUST_ID in this case.

• We have split the information into two
tables so that having multiple occurrences
of the same data ( i.e. CUST_ID, CITY)
can be avoided. This is the basic concept
of a relational database design.
• Breaking data into multiple tables makes
storage of data more efficient, data is easy
to manipulate and large amount of data is
easy to handle.

• When data is stored in multiple tables, we
can access the data in these tables with
the help of a mechanism called JOIN.
• For creating a join we have to specify all
the tables to be included and how they are
related to each other

• When columns in different tables are
joined, we have to qualify column names
with their corresponding table names.
e.g.
• SELECT NAME,AMT
FROM BILL,CUST WHERE
CUST.CUST_ID=BILL.CUST_ID
ORDER BY NAME;
• Order of tables specified with FROM can
be changed.

• The join we have used here is called as
Equijoin or Inner Join. A slightly different
syntax can also be used as follows.
• SELECT NAME ,AMT
FROM CUST INNER JOIN BILL
ON BILL.CUST_ID=CUST.CUST_ID
ORDER BY NAME;

SELECT NAME ,AMT
FROM BILL INNER JOIN CUST
ORDER BY NAME;
SELECT NAME,AMT
CUST.CUST_ID=BILL.CUST_ID AND
AMT>=10000;

• SELECT NAME,AMT
FROM BILL INNER JOIN CUST ON
CUST.CUST_ID=BILL.CUST_ID AND
AMT>=10000;

NAME AMT
GEETA 11000
GEETA 10000
ANAND 16000
ANAND 11000
RAHUL 10000
RAHUL 10000
LATA 12000
AJAY 11000

• SELECT CUST.CUST_ID,NAME ,AMT
FROM CUST INNER JOIN BILL
ORDER BY NAME;

CUST_ID CNAME AMT
7 AJAY 11000
7 AJAY 5000
3 ANAND 16000
3 ANAND 11000
4 ATUL 16000
4 ATUL 9000
2 GEETA 11000
6 LATA 12000
5 RAHUL 10000

• To access data in all the columns of
each of the tables CUST and BILL we
use SELECT * in JOIN as follows
SELECT CUST.*, BILL.*
CUST.CUST_ID=BILL.CUST_ID
ORDER BY NAME;

or
SELECT CUST.* ,BILL.*
FROM BILL INNER JOIN CUST
ORDER BY NAME;

• Same task can be accomplished with the
help of statement
SELECT C.* , B.*
FROM BILL AS B INNER JOIN CUST AS C
ON B.CUST_ID=C.CUST_ID ORDER BY
NAME;
B is called as alias of BILL table and C is an
alias of CUST table. Aliases are used to
improve readability of MySQL statements.
We need not type table name every time.

CUST_ID NAME CITY PHONE CUST_ID BILLNO AMT DT_PUR
7 AJAY MUMBAI 7 252 11000 2007-08-04
7 AJAY MUMBAI 7 265 5000
3 ANAND PUNE 4545545 3 262 16000
3 ANAND PUNE 4545545 3 263 11000
4 ATUL MUMBAI 4 259 16000 2009-09-09
4 ATUL MUMBAI 4 264 9000
2 GEETA NAGPUR 24444444 2 261 11000
6 LATA PUNE 6 266 12000 2009-09-09
5 RAHUL MUMBAI 5 251 10000 2007-10-10

• Subqueries:
A query that is wrapped within another
query. It is also known as inner query.
A subquery is a SELECT statement within
another statement. Subqueries always
appear as part of WHERE clause or
HAVING clause.

In WHERE clause subqueries select the
individual rows. A subquery is always
enclosed in the parentheses. A subquery
must produce a single column of data as
its result, that means we can not use
SELECT * in a subquery.

• Outer Query:
A query which contains an inner query or
subquery.
• Inner Query:
A query inside another query. It is also
known as subquery.

The ORDER BY clause can not be used in a
subquery. Since the results of a subquery
are used internally and are not displayed
ordering does not make much sense. We
can specify ORDER BY in the main query or
outer query. e.g.
SELECT CUST_ID,NAME,
(SELECT SUM(AMT) FROM BILL
WHERE CUST.CUST_ID=BILL.CUST_ID)
FROM CUST ORDER BY NAME;

In this example SELECT CUST_ID,NAME is
called as the outer query or main query and
(SELECT SUM(AMT) FROM BILL
WHERE CUST.CUST_ID=BILL.CUST_ID)
is called as the subquery.
The above example is a correlated
subquery as reference to the table CUST is
made in it. Table name CUST appears in the
outer query.

• Noncorrelated Subquery:
A subquery that stands alone and does not
reference anything from the outer query.
• Correlated Subquery:
A subquery that relies on values returned
from the outer query

A subquery can be constructed using IN
clause, for e.g.
SELECT CUST_ID, NAME, CITY
FROM CUST WHERE CUST_ID IN
(SELECT CUST_ID FROM BILL WHERE
AMT>=10000) ORDER BY NAME;

CUST_ID NAME CITY
7 AJAY MUMBAI
3 ANAND PUNE
4 ATUL MUMBAI
2 GEETA NAGPUR
6 LATA PUNE
5 RAHUL MUMBAI

This query displays CUST_ID and NAME
from CUST table in alphabetical order of
name for those customers whose AMT is
greater than or equal to 10000.

To retrieve CUST_ID, AMT for those
customers who have AMT>=AVG(AMT) we
use a subquery as
SELECT CUST_ID, AMT FROM BILL
WHERE
AMT>=(SELECT AVG(AMT) FROM BILL);

• Subquery using HAVING clause:
Suppose we want to retrieve CUST_ID,
AVG(AMT) for all those customers who have
AVG(AMT) more than AVG(AMT) of the
entire table then we type a subquery using
HAVING clause as

SELECT CUST_ID,AVG(AMT) FROM BILL
AVG(AMT)>(SELECT AVG(AMT)FROM
BILL);

• Transaction processing is used to maintain
database integrity. It is used to ensure that
the batches of MySQL operations execute
completely or not at all. For e.g. if a row is
wrongly deleted then this can be undone
with the help of ROLLBACK.
• Transaction processing is used to manage
INSERT, UPDATE and DELETE
statements. We can not roll back CREATE,
DROP or SELECT statements.

To start a transaction we use the statement
START TRANSACTION
• For e.g.
SELECT * from CUST;
START TRANSACTION;
DELETE FROM CUST;
SELECT * FROM CUST;
ROLLBACK;
The deleted rows are retrieved using ROLLBACK.

• MySQL statements are usually executed
and written directly to database tables.
This is called implicit commit. This does
not happen within a transaction block.
We can undo the previous MySQL
statements that appear within START
TRANSACTION. This is done with help of
ROLLBACK.

• To force explicit commit, the commit statement is
used
For e.g.
START TRANSACTION;
SELECT * FROM CUST;
DELETE FROM CUST WHERE CITY ='PUNE';
SELECT * FROM CUST;
COMMIT;
SELECT * FROM CUST;
Rows with city name PUNE will be deleted.
Transaction block ends after COMMIT or
ROLLBACK.

Mangala Deshpande MySQL0710.ppt

More Related Content

Similar to Mangala Deshpande MySQL0710.ppt (20)

Recently uploaded (20)

Mangala Deshpande MySQL0710.ppt