CHAPTER 6:

DATABASE
 MYSQL Database System
 MySQL is a very popular, open source database.
 Officially pronounced “my Ess Que Ell”.
 Handles very large databases; very fast
performance.
 Why are we using MySQL?
 Free (much cheaper than Oracle!)
 Each student can install MySQL locally.
 Easy to use Shell for creating tables, querying tables, etc.
 Easy to use with Java JDBC

2
 MySQL Architecture
Three layer model: The application layer contains common
network services for connection handling,
authentication and security. This layer is where
different clients interact with MySQL these
clients can written in different API's:.NET, Java,
C, C++, PHP, Python, Ruby, Tcl, Eiffel, etc...
The Logical Layer is where the MySQL
intelligence resides, it includes functionality for
query parsing, analysis, caching and all built-in
functions (math, date...). This layer also
provides functionality common wit
across the
storage engines. s

The Physical Layer is responsible for storing

and retrieving all data stored in “MySQL”.
Associated with this layer are the storage
engines, which MySQL interacts with very basic
standard API's. Each storage engine has it
strengths and weakness, some of this engines
are MyISAM, InnoDB, CSV, NDB Cluster, Falcon,
etc...
 MySQL Architecture
Some internal components:

Each client connection gets its own thread within the

server process.

When clients (applications) connect to the MySQL server,

the server needs to authenticate them.

Before even parsing the query, though, the server consults

the query cache, which only stores SELECT statements,
along with their result sets.

The storage engine does affect how the server optimizes

query.
2-Tier Architecture

Web
Web
Server
Browser
(Client)
PHP

5
 3-Tier Architecture

Web Web Database

Browser Server PHP
Server
(Client)

6
 Client-Server Interaction

Make a request
(SQL query)

MySQL Client
Server Get results Program

Client program can be a MySQL command line client,

GUI client, or a program written in any language such
as C, Perl, PHP, Java that has an interface to the
MySQL server.

7
 Entering commands (1)
 Show all the databases
 SHOW DATABASES;
mysql> SHOW DATABASES;
+-------------+
| Database |
+-------------+
| bookstore |
| employee_db |
| mysql |
| student_db |
| test |
| web_db |
+-------------+

8
 Entering commands (2)
 Choosing a database and showing its
tables
 USE test;
SHOW tables;
mysql> USE test;
Database changed
mysql> SHOW tables;
+----------------+
| Tables_in_test |
+----------------+
| books |
| name2 |
| names |
| test |
+----------------+
4 rows in set (0.00 sec)
mysql>

9
 Entering commands (3)
 Show the structure of a table
 DESCRIBE names;
mysql> DESCRIBE names;
+-----------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+----------------+
| id | int(11) | | PRI | NULL | auto_increment |
| firstName | varchar(20) | | | | |
| lastName | varchar(20) | | | | |
+-----------+-------------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

mysql>

10
 Entering commands (4)
 Show the rows of a table (all columns)
 SELECT * FROM names;
mysql> SELECT * FROM names;
+----+-----------+------------+
| id | firstName | lastName |
+----+-----------+------------+
| 1 | Fred | Flintstone |
| 2 | Barney | Rubble |
+----+-----------+------------+
2 rows in set (0.00 sec)

mysql>

11
 Entering commands (5)
 Inserting a new record
 INSERT INTO names (firstName,
lastName) VALUES ('Rock','Quarry');
 SELECT * FROM names;
mysql> INSERT INTO names (firstName, lastName) VALUES ('Ralph', 'Quarry');
Query OK, 1 row affected (0.02 sec)
mysql> SELECT * FROM names;
+----+-----------+------------+
| id | firstName | lastName |
+----+-----------+------------+
| 1 | Fred | Flintstone |
| 2 | Barney | Rubble |
| 3 | Ralph | Quarry |
+----+-----------+------------+
3 rows in set (0.00 sec)
mysql>

12
 Entering commands (6)
 Updating a record
 UPDATE names SET lastName = 'Stone'
WHERE id=3;
 SELECT * FROM names;
mysql> UPDATE names SET lastName = 'Stone' WHERE id=3;
Query OK, 1 row affected (0.28 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> SELECT * FROM names;
+----+-----------+------------+
| id | firstName | lastName |
+----+-----------+------------+
| 1 | Fred | Flintstone |
| 2 | Barney | Rubble |
| 3 | Ralph | Stone |
+----+-----------+------------+
3 rows in set (0.00 sec)
mysql>
13
 Database concepts (1)
 A relational database management
system consists of a number of
databases.
 Each database consists of a number of
column
tables. headings
 Example table
isbn title author pub year price
books
rows
table
(records)

14
 Some SQL data types (1)
 Each entry in a row has a type
specified by the column.
 Numeric data types
 TINYINT, SMALLINT, MEDIUMINT,
 INT, BIGINT
 FLOAT(display_length, decimals)
 DOUBLE(display_length, decimals)
 DECIMAL(display_length, decimals)

NUMERIC is the same as DECIMAL

15
 Some SQL data types (2)
 Date and time types
 DATE

format is YYYY-MM-DD
 DATETIME

format YYYY-MM-DD HH:MM:SS
 TIMESTAMP

format YYYYMMDDHHMMSS
 TIME

format HH:MM:SS
 YEAR

default length is 4

16
 SQL data types (3)
 String types
 CHAR

fixed length string, e.g., CHAR(20)
 VARCHAR

variable length string, e.g., VARCHAR(20)
 BLOB, TINYBLOB, MEDIUMBLOB, LONGBLOB

same as TEXT, TINYTEXT ...
 ENUM

list of items from which value is selected

17
 SQL commands SHOW,
USE
 SHOW
 Display databases or tables in current
database;
 Example (command line client):
 show databases;
 show tables;
 USE
 Specify which database to use
 Example
 use bookstore;
18
 The CREATE Command (1)
 CREATE creates a database table
CREATE TABLE table_name
(
column_name1 column_type1,
column_name2 column_type2,
...
column_nameN column_typeN
);

Note: To create a database use the statement

CREATE db_name;
19
 The CREATE Command (2)
 Specifying primary keys
CREATE TABLE table_name
(
column_name1 column_type1 NOT NULL
DEFAULT '0',
column_name2 column_type2,
...
column_nameN column_typeN,
PRIMARY KEY (column_name1)
);
20
 The CREATE Command (3)
 autoincrement primary integer keys
CREATE TABLE table_name
(
column_name1 column_type1 PRIMARY
KEY NOT NULL DEFAULT '0'
AUTO_INCREMENT,
column_name2 column_type2,
...
column_nameN column_typeN,
);
21
 The CREATE Command (4)
 Can also create UNIQUE keys. They are
similar to PRIMARY KEYS but can have
NULL values.
 Can also create INDEX fields.

22
 Conditional Creation
 Conditional database creation
 CREATE DATABASE IF NOT EXISTS
db_name;
 Conditional table creation
 CREATE TABLE IF NOT EXISTS
table_name;

23
 The DROP Command
 To delete databases and tables use the
DROP command
 Examples
 DROP DATABASE db_name;
 DROP DATABASE IF EXISTS db_name;
 DROP TABLE table_name;
 DROP TABLE IF EXISTS table_name;

Note: Don't confuse DROP with DELETE which deletes rows

of a table.

24
 The INSERT Command
 Inserting rows into a table
INSERT INTO table_name
( col_1, col_2, ..., col_N)
VALUES
( val_1, val_2, ...,
val_N);

String values are enclosed in single quotes by default

but double quotes are also allowed. Literal quotes
need to be escaped using \' and \"

25
 The SELECT Command (1)
 Selecting rows from a table
 Simplest form: select all columns
SELECT * FROM table_name;
 Select specified columns
SELECT column_list FROM table_name;
 Conditional selection of rows
SELECT column_list FROM table_name
WHERE condition;

26
 The SELECT Command (2)
 Specifying ascending row ordering
SELECT column_list FROM table_name
WHERE condition
ORDER by ASC;
 Specifying descending row ordering
SELECT column_list FROM table_name
WHERE condition
ORDER by DESC;

27
 The SELECT Command (3)
 There are many other variations of the
select command.
 Example: finding the number of records
in a table assuming a primary key
called id:
SELECT COUNT(id) FROM table_name

 Can also perform searching using the

WHERE option
28
 The UPDATE Command
 Used to modify an existing record
UPDATE table_name
SET col_1 = 'new_value1',
..., col_n = 'new_value2';
 Conditional update version
UPDATE table_name
SET col_1 = 'new_value1',
..., col_n = 'new_value2'
WHERE condition;
29
 marks.sql (1)
studentID first_name last_name mark
marks
table

USE test;
CREATE TABLE marks (
studentID SMALLINT AUTO_INCREMENT NOT NULL,
first_name VARCHAR(20) NOT NULL,
last_name VARCHAR(20) NOT NULL,
mark SMALLINT DEFAULT 0 NOT NULL,
PRIMARY KEY (studentID)
);

30
 marks.sql (2)
-- Insert some rows into marks table
INSERT INTO marks (first_name, last_name,
mark) VALUES ('Fred', 'Jones', 78);
INSERT INTO marks (first_name, last_name,
mark) VALUES ('Bill', 'James', 67);
INSERT INTO marks (first_name, last_name,
mark) VALUES ('Carol', 'Smith', 82);
INSERT INTO marks (first_name, last_name,
mark) VALUES ('Bob', 'Duncan', 60);
INSERT INTO marks (first_name, last_name,
mark) VALUES ('Joan', 'Davis', 86);

31
 The Marks Table
 Selecting the complete table
SELECT * FROM marks;

+-----------+------------+-----------+------+
| studentID | first_name | last_name | mark |
+-----------+------------+-----------+------+
| 1 | Fred | Jones | 78 |
| 2 | Bill | James | 67 |
| 3 | Carol | Smith | 82 |
| 4 | Bob | Duncan | 60 |
| 5 | Joan | Davis | 86 |
+-----------+------------+-----------+------+
5 rows in set (0.00 sec)

32
 The WHERE Clause (1)
 Select rows according to some criterion
SELECT * FROM marks WHERE studentID > 1
AND studentID < 5;

+-----------+------------+-----------+------+
| studentID | first_name | last_name | mark |
+-----------+------------+-----------+------+
| 2 | Bill | James | 67 |
| 3 | Carol | Smith | 82 |
| 4 | Bob | Duncan | 60 |
+-----------+------------+-----------+------+
3 rows in set (0.01 sec)

33
 The WHERE Clause (2)
 Select rows with marks >= 80
SELECT * FROM marks WHERE mark >= 80;

+-----------+------------+-----------+------+
| studentID | first_name | last_name | mark |
+-----------+------------+-----------+------+
| 3 | Carol | Smith | 82 |
| 5 | Joan | Davis | 86 |
+-----------+------------+-----------+------+
2 rows in set (0.00 sec)

34
 The ORDER BY Clause
 Select rows according to some criterion
SELECT * FROM marks ORDER BY mark DESC;

+-----------+------------+-----------+------+
| studentID | first_name | last_name | mark |
+-----------+------------+-----------+------+
| 5 | Joan | Davis | 86 |
| 3 | Carol | Smith | 82 |
| 1 | Fred | Jones | 78 |
| 2 | Bill | James | 67 |
| 4 | Bob | Duncan | 60 |
+-----------+------------+-----------+------+
5 rows in set (0.00 sec)

35
 Searching Using LIKE (1)
 LIKE is used to search a table for
values containing a search string:
 There are two wild-card characters
used to specifiy patterns:
 _ matches a single character
 % matches zero or more characters
 Can also use NOT LIKE
 Searching is case insensitive

36
 Searching Using LIKE (2)
 Example: last names in marks table
that begin with J
SELECT * FROM marks WHERE last_name
LIKE 'J%';

 Example: first names that have 3

letters
SELECT * FROM marks WHERE first_name
LIKE '_ _ _';

37
 Quoting strings
 If a string contains a single quote it
must be backquoted (escaped) before
it can be used in a query
 Example: find records containing
O'Reilly in the last_name field.
SELECT * FROM marks WHERE last_name
= 'O\'Reilly';

38
 Limiting number of rows
 LIMIT can be used to specify the
maximum number of rows that are to
be returned by a select query. Example
 SELECT * FROM marks LIMIT 3;
 This query will return only the first 3
rows from the marks table
 To return 15 rows beginning at row 5
use
 SELECT * FROM marks LIMIT 5, 15;
39
 MySQL Functions (1)
 How many rows are there ?
SELECT COUNT(*) FROM marks;

+----------+
| COUNT(*) |
+----------+
| 5 |
+----------+
1 row in set (0.00 sec)

 Can use COUNT(marks) instead of

COUNT(*)
40
 MySQL Functions (2)
 What is the sum of all the marks?
SELECT SUM(mark) FROM marks;

+-----------+
| SUM(mark) |
+-----------+
| 373 |
+-----------+
1 row in set (0.00 sec)

41
 MySQL Functions (3)
 What is the average mark?
SELECT AVG(mark) FROM marks;

+-----------+
| AVG(mark) |
+-----------+
| 74.6000 |
+-----------+
1 row in set (0.00 sec)

42
 MySQL Functions (4)
 What is the minimum mark?
SELECT MIN(mark) FROM marks;

+-----------+
| MIN(mark) |
+-----------+
| 60 |
+-----------+
1 row in set (0.00 sec)

43
 MySQL Functions (5)
 What is the maximum mark?
SELECT MAX(mark) FROM marks;

+-----------+
| MAX(mark) |
+-----------+
| 86 |
+-----------+
1 row in set (0.00 sec)

44
 books.sql (1)
isbn title author pub year price
books this is a
table simple
design

USE web_db;
CREATE TABLE books (
isbn CHAR(15) PRIMARY KEY NOT NULL,
title VARCHAR(100) NOT NULL,
author VARCHAR(100) NOT NULL,
pub VARCHAR(20) NOT NULL,
year YEAR NOT NULL,
price DECIMAL(9,2) DEFAULT NULL
);
45
 books.sql (2)
-- Insert some books into books table
INSERT INTO books VALUES ('0-672-31784-2',
'PHP and MySQL Web Development',
'Luke Welling, Laura Thomson',
'Sams', 2001, 74.95
);
INSERT INTO books VALUES ('1-861003-02-1',
'Professional Apache',
'Peter Wainwright',
'Wrox Press Ltd', 1999, 74.95
);

46
 employee_db.sql (1)
employeeID name position address
employees
table

employeeID hours
jobs
table

CREATE DATABASE IF NOT EXISTS employee_db;

USE employee_db;
DROP TABLE IF EXISTS employees;
DROP TABLE IF EXITS jobs;
47
 employee_db.sql (1)
CREATE TABLE employees (
employeeID SMALLINT NOT NULL,
name VARCHAR(20) NOT NULL,
position VARCHAR(20) NOT NULL,
address VARCHAR(40) NOT NULL,
PRIMARY KEY (employeeID)
);
INSERT INTO employees VALUES (1001, 'Fred',
'programmer', '13 Windle St');
INSERT INTO employees VALUES (1002, 'Joan',
'programmer', '23 Rock St');
INSERT INTO employees VALUES (1003, 'Bill',
'manager', '37 Front St');
48
 employee_db.sql (2)
CREATE TABLE jobs (
employeeID SMALLINT NOT NULL,
hours DECIMAL(5,2) NOT NULL,
);
INSERT INTO jobs VALUES (1001, 13.5);
INSERT INTO jobs VALUES (1002, 2);
INSERT INTO jobs VALUES (1002, 6.25);
INSERT INTO jobs VALUES (1003, 4);
INSERT INTO jobs VALUES (1001, 1);
INSERT INTO jobs VALUES (1003, 7);
INSERT INTO jobs VALUES (1003, 9.5);

49
 Select Queries With Joins
(1)
 Cartesian product query
SELECT * FROM employees, jobs;

+------------+------+------------+--------------+------------+-------+
| employeeID | name | position | address | employeeID | hours |
+------------+------+------------+--------------+------------+-------+
| 1001 | Fred | programmer | 13 Windle St | 1001 | 13.50 |
| 1002 | Joan | programmer | 23 Rock St | 1001 | 13.50 |
| 1003 | Bill | manager | 37 Front St | 1001 | 13.50 |
| 1001 | Fred | programmer | 13 Windle St | 1002 | 2.00 |
| 1002 | Joan | programmer | 23 Rock St | 1002 | 2.00 |
| 1003 | Bill | manager | 37 Front St | 1002 | 2.00 |
| 1001 | Fred | programmer | 13 Windle St | 1002 | 6.25 |
| 1002 | Joan | programmer | 23 Rock St | 1002 | 6.25 |
| 1003 | Bill | manager | 37 Front St | 1002 | 6.25 |

50
 Select Queries With Joins
(2)
 Cartesian product query (continued)
| 1001 | Fred | programmer | 13 Windle St | 1003 | 4.00 |
| 1002 | Joan | programmer | 23 Rock St | 1003 | 4.00 |
| 1003 | Bill | manager | 37 Front St | 1003 | 4.00 |
| 1001 | Fred | programmer | 13 Windle St | 1001 | 1.00 |
| 1002 | Joan | programmer | 23 Rock St | 1001 | 1.00 |
| 1003 | Bill | manager | 37 Front St | 1001 | 1.00 |
| 1001 | Fred | programmer | 13 Windle St | 1003 | 7.00 |
| 1002 | Joan | programmer | 23 Rock St | 1003 | 7.00 |
| 1003 | Bill | manager | 37 Front St | 1003 | 7.00 |
| 1001 | Fred | programmer | 13 Windle St | 1003 | 9.50 |
| 1002 | Joan | programmer | 23 Rock St | 1003 | 9.50 |
| 1003 | Bill | manager | 37 Front St | 1003 | 9.50 |
+------------+------+------------+--------------+------------+-------+
21 rows in set (0.01 sec)

The cartesian product query is rarely what we want.

51
 Select Queries With Joins
(3)
 Substitution
SELECT name, hours FROM employees, jobs WHERE
employees.employeeID = jobs.employeeID;

+------+-------+
| name | hours |
+------+-------+
| Fred | 13.50 |
Here we are replacing
| Joan | 2.00 | the employeeID
| Joan | 6.25 | numbers in the jobs
| Bill | 4.00 |
| Fred | 1.00 | table by the employee's
| Bill | 7.00 | name
| Bill | 9.50 |
+------+-------+
7 rows in set (0.00 sec)

52
 Select Queries With Joins
(4)
 Entries only for Fred
SELECT name, hours FROM employees, jobs WHERE
employees.employeeID = jobs.employeeID AND
name = 'Fred';

+------+-------+
| name | hours |
+------+-------+
| Fred | 13.50 |
| Fred | 1.00 |
+------+-------+
2 rows in set (0.00 sec)

53
 Select Queries With Joins
(5)
 Total hours worked for each person
SELECT name, SUM(hours) FROM employees, jobs
WHERE employees.employeeID = jobs.employeeID
GROUP BY name;

+------+------------+
| name | SUM(hours) |
+------+------------+
| Bill | 20.50 |
| Fred | 14.50 |
| Joan | 8.25 |
+------+------------+
3 rows in set (0.00 sec)

54
 Select Queries With Joins
(6)
 Total hours worked, for Fred
SELECT name, SUM(hours) FROM employees, jobs
WHERE employees.employeeID = jobs.employeeID
AND name = 'Fred' GROUP BY name;

+------+------------+
| name | SUM(hours) |
+------+------------+
| Fred | 14.50 |
+------+------------+
1 row in set (0.00 sec)

55