1 1 CS3336a, Alex Babanski CS3336a, Alex Babanski <?php echo ...

CS3336A, Alex Babanski 

Database is simply a collection of data. 

In relational database, data is organized into tables. 

Student_ID Name Major Grade 

10145 Michael CS 95 

10146 Dennis PHYS 75 

10147 Boris MATH 89 

… … … 

Database Management System (DBMS) is a software to maintain 

and utilize the collections of data (Oracle, DB2, MySQL) 


Database 

The overall collection of data –may consist of many tables 

Table 

An individual "relation" in the relational database 

Relates keys to values. 

Table Column 

An attribute in the table 

Table Row 

An entity in the table 

Typically has a value for each column 

Student_ID Name Major Grade 




… … … 

1


Key 

An attribute that uniquely identifies an entity 

Example: Student ID 10147 identifies student 'Boris' 

Foreign Key 

Key used to relate data in one table with data in another table 

Schema 

A description of a particular collection of data 

(a set of table designs that determine a database). 

Does not yet include the data –simply shows how it will be 

structured in the database 


Transaction 

A sequence of database actions (reads/writes). 

ACID Properties: 

Atomicity (all‐or‐nothing property) 

Consistency (rows affected by transaction remain consistent) 

Isolation (no transaction interference) 

Durability (committed transactions are protected against crashes) 

Database Engine ("Storage Engine") 

Is the underlying software component for storing, processing and 

securing data. 

2


Query Optimization 

and Execution 

A typical DBMS has a layered architecture. 

Each database system has its own variations. 

Relational Operators 

Files and Access Methods 

Buffer Management 

Disk Space Management 

These layers must consider concurrency 

control and recovery. 

DB 


Relationships: how does the data in different tables relate 

One‐to‐One 

An entity in a table corresponds to a single entity in another table. 

The relationship is typically established using a foreign key for one or both entities. 

Example: If we have a table for Student_Info and a table for Academic_History, 

there is a one‐to‐one relationship between them. 

One‐to‐Many 

An entity in a table corresponds to 1 or more entities in another table. 

Example: If the table for Academic_History has an entry for each term, the relationship now 

becomes one student to many terms. 

3


Many‐to‐Many 

Multiple entities in one table correspond to multiple entities in another table. 

This relationship is often defined by a separate table, 

which in fact changes it into 2 One-to-Many relationships 

Example: Tables Student_Info and Courses_Taken have a many to many relationship, 

since a student can take many courses and each course can be taken by many students. 

However, if we create a new table Student_Courses, we can have each entity be a pair: 

Student_Id, Course_id 

Now Student_Info has a one to many relationship with Student_Courses, 

and so does Courses_Taken 


There is a lot of database theory about how to best create a schema: 

• Best modeling the data you are storing 

• Storing it most efficiently 

• Designing most efficient queries 

The process of organizing data to minimize redundancy is called normalization. 

We will talk about it later on. Check introduction: 

http://babanski.com/files/MySQL‐intro‐to‐database‐normalization.pdf 

We are concerned with the fundamentals, and for using MySQL 

through PHP and a Web interface. 

4


MySQL is a Database Management System. 

SQL stands for the Structured Query Language. 

It defines how to insert, retrieve, modify and delete data 

Most Popular open source software: http://www.mysql.com 

Who uses it 

Virtually every major company/corporation: http://www.mysql.com/why‐mysql/marketshare/ 

• MySQL is a free and open source relational database management system. 

• MySQL has more than 20 million installations. 

• MySQL runs as a server providing multi‐user access to a number of databases. 

• It is a cross platform database server. 

• Multiple storage engines (MyISAM, InnoDB…) 

• Views creation and update 

• Transactions with the InnoDB Engine 

• Sub Queries / Nested Select 

• Primary key and indexing Current Versions: 5.1 (released in 2009), 5.5 (released in 2011) 


• Create table 

• Insert records 

• Retrieve records 

• Update records 

• Delete records 

• Modify table 

• Join table 

• Drop table 

• Count, Like, Order by, Group by, limit 

• Optimize table 

• Advanced (sub‐queries, stored procedures, triggers, views …) 

http://dev.mysql.com/doc/refman/5.5/en/differences‐from‐ansi.html 

5


CSV 

The engine stores data in text files using comma‐separated values format. 

Memory 

The engine creates tables with contents that are stored in memory. 

MyISAM 

Default in 5.1. 

Non‐transaction Engine. 

No transaction overhead: much faster, lower disk space requirements, less memory required to 

perform updates. 

Atomicity (all‐or‐nothing property) 

Consistency (rows affected by transaction remain consistent) 

Isolation (no transaction interference) 

Durability (committed transactions are protected against crashes) 

InnoDB 

Default in 5.5. 

Transaction‐safe (ACID compliant) Engine. 

Safe, can combine many statements with one COMMIT, can execute ROLLBACK, row‐level locking. 

http://dev.mysql.com/doc/refman/5.5/en/storage‐engines.html 

http://dev.mysql.com/doc/refman/5.1/en/storage‐engine‐compare‐transactions.html 


A MySQL server can store several databases. 

Databases are usually stored as directories (MyISAM). 

Tables are stored as files inside each database (directory). 

Default location for all files: /var/lib/mysql/ 

Each MyISAM table has three files: 

• table.FRM file containing information about the table structure. 

• table.MYD file containing the row data. 

• table.MYI containing any indexes belonging with this table, as well as some 

statistics about the table. 

InnoDB: 

Data and indexes in tablespaces. Made up of one of more datafiles. 

6


MySQL allows console access: 

mysql –h hostname –u username –p [password] 

Typical usage (localhost): 

shell> mysql ‐u someusername ‐p 

Enter password: ***** 

Create file .my.cnf 

[client] 

user="someusername" 

pass="1234567" 

Server version: 5.xx.xxxx (Debian) 

Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. 

This software comes with ABSOLUTELY NO WARRANTY. 

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement. 

mysql> 


CREATE 

create databases and tables 

ALTER 

alter the structure of a table 

INSERT 

insert a new row in a table 

UPDATE 

update rows in a table 

SELECT 

select table rows based on certain conditions 

DELETE 

delete one or more rows of a table 

Data Manipulation Statements 

http://dev.mysql.com/doc/refman/5.5/en/sql‐syntax‐data‐manipulation.html 

7


CREATE a database: 

mysql> CREATE DATABASE databasename; 

USE a database: 

mysql> USE databasename; 

Important!! You need to have permissions to create a database. 

Your CS3336.com account doesn't have enough privileges to create a database. 

However, you can create as many tables as you want in the database given to you. 

For CPANEL users: 

In CPANEL databasename starts with login name and '_'. 

For instance, if your login name is csab123 then all your databases should start with csab123_ 

‐ i.e. csab123_db , csab123_db2 , etc 

Keep it in mind when you create databases in shell on a server with CPANEL installed. 


MySQL commands are NOT case‐sensitive. 

Often, command keywords are written in all caps, just to 

distinguish them from your user‐specific values such as table 

and column names. However, this isn’t necessary. 

MySQL commands have to end with a semicolon (;). 

If you forget this, the system will put an arrow on the next line: ‐> 

which means it is waiting for you to finish the command. 

mysql> show databases 

‐> 

8


Execute Two statements, 

Fist statement –we need to select 

database 'babanski_db' 

Result 

http://phpmyadmin.cs3336.com 


What are the current databases on the server 

mysql> SHOW databases; 

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

| Database | 

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

| information_schema | 

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

Use PHPMyAdmin SQL statements 

http://phpmyadmin.cs3336.com 

Create a database (make a directory): 

mysql> CREATE database cs3336_db; 

Select database to use: 

mysql> USE cs3336_db; 

Database changed 

Can do it as root‐privileged user only 

What tables are currently stored in the cs3336_db database 

mysql> SHOW tables; 

Empty set (0.00 sec) 

9


Show tables in the database (select database first using 'use' command): 

mysql> SHOW tables; 

Describe structure of a table in the database: 

mysql> DESCRIBE tablename; 

mysql> use cs3336_hw4; 

Database changed 

mysql> desc countries; 

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

| Field | Type | Null | Key | Default | Extra | 

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

| countryID | char(2) | NO | PRI | | | 

| country | varchar(200) | YES | | NULL | | 

| active | enum('YES','NO') | NO | | YES | | 

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

3 rows in set (0.00 sec) 

Select all data/records from a table: 

mysql> SELECT * from tablename; 

Use a condition clause to get a specific data/records from a table: 

mysql> SELECT * from students WHERE name='Boris'; 


Grant access to a database: 

mysql> GRANT all on databasename.* to username@localhost identified by 'password'; 

Grant limited access to a database: 

mysql> GRANT select, insert on databasename.* to username@localhost identified by 'password'; 

Delete user/privileges: 

mysql> DROP USER 'username'; 

Flush privileges!: 

mysql> FLUSH privileges; 

See a list of the privileges granted to a specific user: 

mysql> SHOW GRANTS for 'username'@'localhost'; 

mysql> show grants for 'root'@'localhost'; 

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

| Grants for root@localhost | 

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

| GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY PASSWORD '*ED1B38B………' WITH GRANT OPTION | 

| GRANT PROXY ON ''@'' TO 'root'@'localhost' WITH GRANT OPTION | 

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

2 rows in set (0.00 sec) 

10


CHAR () (size < 255 bytes) 

VARCHAR() (size < 255 bytes) 

BLOB or TEXT (size < 65,535 bytes) 

MEDIUMBLOB or MEDIUMTEXT (size < 16,777,215 bytes) 

LONGBLOB or LONGTEXT (size < 4 GB) 

ENUM (, ,…) 

TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 

are integers of 1, 2, 3, 4, and 8 bytes, respectively. 

DECIMAL or NUMERIC(M, D) 

FLOAT 

DOUBLE 

DATE (default format YYYY‐MM‐DD) 

http://dev.mysql.com/doc/refman/5.5/en/data‐types.html 


File: table.sql 

DROP TABLE IF EXISTS `students`; 

SET character_set_client = utf8; 

CREATE TABLE `students` ( 

`studentID` int unsigned NOT NULL auto_increment, 

`name` varchar(100) NOT NULL default '', 

`major` varchar(50) NOT NULL default '', 

`grade` tinyint NOT NULL default '0', 

PRIMARY KEY (`studentID`) 

) ENGINE=MyISAM DEFAULT CHARSET=utf8; 

StudentID name major grade 




… … … 

Import into cs3336_db database using console access: 

shell> mysql ‐u username ‐p < table.sql 

11













10148 Katya CS 0 

INSERT data into the table: 

mysql> insert into students values ('','Michael', 'CS', 95); 

We 'override' auto_increment 

mysql> insert into students values (10146,'Dennis', 'PHYS', 75); 

mysql> insert into students (name, major, grade) values ('Boris', 'MATH', 89); 

mysql> insert into students set name='Katya', major='CS'; 

Different syntax 

http://dev.mysql.com/doc/refman/5.5/en/insert.html 














SELECT all records from the table: 

mysql> select * from students; 

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

| studentID | name | major | grade | 

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

| 1 | Michael | CS | 95 | 

| 10146 | Dennis | PHYS | 75 | 

| 10147 | Boris | MATH | 89 | 

| 10148 | Katya | CS | 0 | 

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

http://dev.mysql.com/doc/refman/5.5/en/select.html 

Use \G modifier for many‐column data: 

mysql> select * from students\G; 

*************************** 1. row *************************** 

studentID: 1 

name: Michael 

major: CS 

grade: 95 

*************************** 2. row *************************** 

studentID: 10146 

name: Dennis 

major: PHYS 

grade: 75 

*************************** 3. row *************************** 


name: Boris 

major: MATH 

grade: 89 

*************************** 4. row *************************** 


name: Katya 

major: CS 

grade: 0 

12














SELECT specific data/columns from the table: 

mysql> select studentID, name from students; 

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

| studentID | name | 

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

| 1 | Michael | 

| 10146 | Dennis | 

| 10147 | Boris | 

| 10148 | Katya | 

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


Important! 

Always select only data you need! 














SELECT specific data from the table and limit output: 

mysql> select studentID, name from students limit 2; 

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

| studentID | name | 

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

| 1 | Michael | 

| 10146 | Dennis | 

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

Important to create 'pages' with records 

Syntax: limit offset, row_count 

limit 2 is equivalent to limit 0, 2 


13














SELECT specific data from the table with WHERE clause: 

mysql> select name, major, grade from students where major='cs'; 

mysql> select name, major, grade from students where major='c%'; 

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

| name | major | grade | 

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

| Michael | CS | 95 | 

| Katya | CS | 0 | 

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


Question: Is anything wrong with my select 

Check Case‐Sensitivity issue! 

http://dev.mysql.com/doc/refman/5.0/en/case‐sensitivity.html 














More examples of WHERE clause: 

mysql> select * from students where grade>75; 

mysql> select name, grade from students where major in ('CS', 'phys'); 

mysql> select * from students where name='michael' and major='cs'; 

mysql> select studentID from students where name='dennis' or major='cs'; 


14














SELECT and ORDER data from the table: 

mysql> select * from students order by grade asc; 

mysql> select * from students order by grade asc, name desc; 

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


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

| 10148 | Katya | CS | 0 | 

| 10146 | Dennis | PHYS | 75 | 

| 10147 | Boris | MATH | 89 | 

| 1 | Michael | CS | 95 | 

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


Secondary rule 














SELECT , ORDER and apply WHERE clause to the data: 

mysql> select * from students where grade>75 order by grade asc; 

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


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

| 10147 | Boris | MATH | 89 | 

| 1 | Michael | CS | 95 | 

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


15


How many students have the same major 






mysql> select major, count(*) as size from students; 

mysql> select major, count(*) as size from students ORDER BY major asc; 

Not what we expected!!! 

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

| major | size | 

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

| CS | 4 | 

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

mysql> select major, count(*) as size from students GROUP BY major asc; 

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

| major | size | 

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

| CS | 2 | 

| MATH | 1 | 

| PHYS | 1 | 

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

Use in conjunction with aggregate functions 

http://dev.mysql.com/doc/refman/5.5/en/group‐by‐functions.html 

http://dev.mysql.com/doc/refman/5.5/en/group‐by‐functions‐and‐modifiers.html 


UPDATE data in the table: 






mysql> update students set grade='65'; 

mysql> update students set grade='65' where grade>75; 

mysql> update students set grade='65' where name='Boris'; 

mysql> update students set grade='65' where studentID='10147'; 

mysql> update students set grade='65', major='CS' where studentID='10147'; 

DELETE data from the table: 

mysql> delete from students; 

mysql> delete from students where studentID='10147'; 

mysql> delete from students where studentID'10147'; 

http://dev.mysql.com/doc/refman/5.5/en/update.html 

http://dev.mysql.com/doc/refman/5.5/en/delete.html 

16


http://dev.mysql.com/doc/refman/5.5/en/functions.html 

mysql> select 1+1 as sumoftwo; 

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

| sumoftwo | 

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

| 2 | 

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

mysql> select IF (1 select now() as currentTime; 

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

| currentTime | 

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

| 2012-11-16 03:39:35 | 

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

mysql> select concat_ws('‐', 'Go', 'Canada'); 

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

| concat_ws('-', 'Go', 'Canada') | 

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

| Go-Canada | 

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

Operators, Control Flow functions, String Functions, Date and Time Functions 


MySQL has many functions available to alter or format the data stored in tables. 

When using a MySQL function specify a column name. 

Functions are: 

• case insensitive 

• no space between function name and parentheses 

Typical syntax: 

Add extra clauses if needed 

(WHERE, ORDER BY, etc) 

SELECT FUNCTION( columnName ) FROM tableName; 

SELECT column1, FUNCTION( column2 ), column3 FROM tableName; 


17


Name 

= 

Description 

http://dev.mysql.com/doc/refman/5.5/en/non‐typed‐operators.html 

Equal operator or Assign a value (as part of a SET statement, or as 

part of the SET clause in an UPDATE statement) 

:= Assign a value 

BETWEEN ... AND ... 

Check whether a value is within a range of values 

& , ^, |, >>, , = ,


Function Usage Purpose 

CONCAT() CONCAT(x,y,…) Creates a new string of the form xy 

CONCAT_WS() CONCAT_WS(separator,x,y) Creates a new strung with separator 

CONV() CONV(n, base, to_base) Converts numbers between diff base 

TRIM() TRIM(column) Trims space from the beginning and end. 

UPPER() UPPER(str) Capitalizes the string 

LOWER() LOWER(str) Makes a string lowercase 

SUBSTR() SUBSTR(str, pos, len) Returns a substring 

LENGTH() LENGTH(str) Returns string length 

http://dev.mysql.com/doc/refman/5.5/en/string‐functions.html 


Function Usage Purpose 

DAY() / MONTH() DAY(date) / MONTH(date) Returns day/month of the date 

CURTIME() CURTIME() Returns the current time 

CURDATE() CURDATE() Returns the current date 

NOW() NOW() Returns the current date and time 

UNIX_TIMESTAMP() UNIX_TIMESTAMP() Returns seconds since 1970‐01‐01 

DATE_ADD() DATE_ADD(date, expr) Returns date adjusted by expr 

DATE_SUB() DATE_SUB(date,expr) Returns date adjusted by expr 

TO_DAYS() TO_DAYS(date) Returns number of days since year 0. 

MySQL Default Datetime format is: 'YYYY‐MM‐DD HH:MM:SS' 

http://dev.mysql.com/doc/refman/5.5/en/date‐and‐time‐functions.html 

MySQL uses what is known as a proleptic Gregorian calendar. 

19


Other Important Functions: 

• Control Flow Functions: 

IF(), IFNULL(), NULLIF(), etc 

• Information Functions: 

FOUND_ROWS(), LAST_INSERT_ID(), etc 

• Encryption and Compression Functions: 

AES_DECRYPT(), AES_ENCRYPT(), MD5(), ENCODE(), etc 

• XML Functions: 

ExtractValue(), UpdateXML() 

• Functions and Modifiers for GROUP BY clauses: 

COUNT(), SUM(), MAX(), MIN() 



• Functions and Modifiers for GROUP BY clauses: 

COUNT() 

‐ Returns the number of matching entries 

SUM() 

‐ Returns the sum of matching values 

MAX() / MIN() ‐ Returns maximum/minimum value of a group 






mysql> select MAX(grade) from students; 

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

| MAX(grade) | 

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

| 95 | 

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

mysql> select MAX(grade) from students GROUP BY major; 

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

| MAX(grade) | 

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

| 95 | 

| 89 | 

| 75 | 

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

http://dev.mysql.com/doc/refman/5.5/en/group‐by‐functions‐and‐modifiers.html 

20


MySQL supports a number of date and time column formats: 

DATE 

‐ Stores a date value in the form YYYY‐MM‐DD. 

For example 2008‐10‐23. 

DATETIME 

‐ Stores a date and time value of the form YYYY‐MM‐DD HH:MM:SS. 

For example 2008‐10‐23 10:37:22. 

The supported range is 1000‐01‐01 00:00:00 to 9999‐12‐31 23:59:59 

TIMESTAMP 

‐ Similar to DATETIME. The main difference is that it's tied to a time zone. 

If you change time_zone on a server then you change TIMESTAMP value. 

The supported range is 1970‐01‐01 00:00:00 UTC to 2038‐01‐03 03:14:07 UTC 

Acceptable (relaxed) values of date/time: 

YYYYMMDDHHMMSS ; YYYY/MM/DD HH*MM*SS; YYYYMMDD ; YYMMDD ; YYYY/MM/DD 

For example, '20070523091528' and '070523091528' are interpreted as '2007‐05‐23 09:15:28', 

but '071122129015' is illegal (it has a nonsensical minute part) and becomes '0000‐00‐00 00:00:00'. 

http://dev.mysql.com/doc/refman/5.5/en/date‐and‐time‐literals.html 


Automatic Initialization and Updating of TIMESTAMP: 

http://dev.mysql.com/doc/refman/5.5/en/timestamp‐initialization.html 

One TIMESTAMP column in a table can have the current timestamp as the default value for initializing the 

column, as the auto‐update value, or both. 

CREATE TABLE t1 ( 

ts TIMESTAMP DEFAULT 0 

); 

The default is the given value. 

In this case, the column has no automatic properties at all. 


ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP 

); 

The default is the current timestamp. 

Column is not automatically updated to the current timestamp. 


ts TIMESTAMP DEFAULT 0 ON UPDATE CURRENT_TIMESTAMP 

); 

Can be NULL 


ts TIMESTAMP 

); 

Equivalent to: 

ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP 

The column is automatically updated to the current 

timestamp and has the given constant default value. 

The column has the current timestamp for its default value and is 

automatically updated to the current timestamp. 

21


Tutorial on MySQL Date and Time Functions: 

http://www.techotopia.com/index.php/Working_with_Dates_and_Times_in_MySQL 

http://dev.mysql.com/doc/refman/5.5/en/date‐and‐time‐functions.html 

Most MySQL indexes (PRIMARY KEY, UNIQUE, INDEX, andFULLTEXT) are stored in B-trees. 


The whole point of using a database, as opposed to a flat file, is to speed up searches. 

One way to markedly increase search speed is to make an index based on your most 

common search criteria. 

Index is a Data structure that improves the speed of data retrieval from a database table 

at the cost of slower writes and increased storage space. 

http://dev.mysql.com/doc/refman/5.5/en/optimization‐indexes.html 

MySQL indexes: PRIMARY KEY, UNIQUE, INDEX, and FULLTEXT 

MySQL uses indexes for these operations: 

• To find the rows matching a WHERE clause quickly. 

• To eliminate rows from consideration. 

• To retrieve rows from other tables when performing joins. 

• To find the MIN() or MAX() value for a specific indexed column. 

• To sort or group a table. 

• In some cases, a query can be optimized to retrieve values without consulting the data rows. 

22


UNIQUE Index (constraint) 

All values in the index must be distinct. 

An error occurs if you try to add a new row with a key value that matches an existing row. 

It permits multiple NULL values for columns that can contain NULL. 

PRIMARY KEY 

Is a unique index (can be multi‐column) where all key columns must be defined as NOT NULL. 

A table can have only one PRIMARY KEY. 

When table is created, an index based on the primary key is automatically constructed. 

In the created table, a PRIMARY KEY is placed first, followed by all UNIQUE indexes, and 

then the non‐unique indexes. 

Primary Key uniquely identifies the rest of the data in any given row. 

Example: Social Insurance Number 

In InnoDB tables, keep the PRIMARY KEY short to minimize storage overhead for secondary indexes. 

Each secondary index entry contains a copy of the primary key. 


Foreign Keys 

If a table has many columns, and you query many different combinations of columns, it 

might be efficient to split the less‐frequently used data into separate tables with a few 

columns each, and relate them back to the main table by duplicating the numeric ID column 

from the main table. That way, each small table can have a primary key for fast lookups of its 

data, and you can query just the set of columns that you need using a join operation. 

Column Indexes / Multiple‐Column Indexes 

The most common type of index involves a single column, storing copies of the values from 

that column in a data structure, allowing fast lookups for the rows with the corresponding 

column values. 

A multiple‐column index can be considered a sorted array. MySQL can use multiple‐column 

indexes for queries that test all the columns in the index, or queries that test just the first 

column, the first two columns, the first three columns, and so on. 

23


Create an Index 

• A column contains a wide rage of values, 

many NULL values. 

• Columns frequently used in a WHERE clause. 

• To retrieve rows < 2~4 % of the total rows 

Do NOT Create an Index 

• Small table 

• Rarely used columns 

• To retrieve rows > 2~4 % of the total rows 

• Frequently updated table. 

An index is made from one or more columns, using the syntax 

CREATE INDEX index_name ON table_name (column_name1, column_name2, ...) 

Confirm Indexes: 

mysql> SHOW INDEX from students; 

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

| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | 

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

| students | 0 | PRIMARY | 1 | studentID | A | 4 | NULL | NULL | | BTREE | 

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


mysql> EXPLAIN [EXTENDED] SELECT ……… 

To obtain information about how MySQL executes a SELECT statement. 

Information from the optimizer about the query execution plan. 

mysql> explain extended select * from students; 

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

| id | select_type | table | type | possible_keys | key | key_len | ref | rows | filtered | Extra | 

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

| 1 | SIMPLE | students | ALL | NULL | NULL | NULL | NULL | 4 | 100.00 | | 

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

To show overall estimated cost of query: 

mysql> SHOW SESSION STATUS LIKE 'Last_query_cost'; 

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

| Variable_name | Value | 

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

| Last_query_cost | 0.000000 | 

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

24


MySQL and Client/Server Model: 

PHP 

Script 

Local 

Recources 

MySQL 

Server 

MySQL 

Server 

Remote 

Resources 

Before you can access a database, a connection to the database must be created. 

The interaction with MySQL server consists of the following steps: 

• Connect to MySQL server (requires a username and password). 

• Select the active database ('use database' analog). 

• Perform SQL queries and retrieve results. 

• Free Results 

• Close connection to MySQL (not needed unless you are using persistent connections) 

http://www.php.net/manual/en/set.mysqlinfo.php 


Connection 

$db_link = mysql_connect("localhost", "dbuser", "dbpass"); 

If ($db_link == false) 

die("Could not connect: ". mysql_error()); 

Database selection: 

mysql_select_db("CS3336_db", $db_link) or die("Could not select database:" . mysql_error()); 

Perform a query: 

$query = "SELECT name, major from students where studentID='10147'"; 

$result = mysql_query($query, $db_link); 

If (!$result) { 

echo "Could not perform insert: ". mysql_error(); } 

else { 

$studentID = mysql_insert_id($db_link); 

} 

mysql_free_result($result); // Free Result 






mysql_close($db_link); 

// Close Connection 


25


Connection 

$db_link = mysql_connect("localhost", "dbuser", "dbpass"); 

If ($db_link == false) 

die("Could not connect: ". mysql_error()); 

Database selection: 

mysql_select_db("CS3336_db", $db_link) or die("Could not select database:" . mysql_error()); 

Processing Multiple Records: 

$result = @mysql_query('Select name, grade as gr FROM students'); 

while ($row = mysql_fetch_array($result)) { 

$name=$row['name']; 

$grade=$row['gr']; 

echo "$name $grade" .''; 

} 






There are a number of ways for retrieving the results of a query. The most commonly used are: 

• mysql_fetch_assoc() returns an associative array where the keys are the record field names. 

• mysql_fetch_object() returns a record as an object. There are object attributes for each record field. 



SQL Injection –Trust NO One! 

Usually you would get the data that you put in your database from the user. 

Make sure that the data will not break your SQL queries. (SQL Injection) 

$sql=" SELECT * FROM students WHERE name = '$badName' " 

// What happens when you pass $badName === " ' OR 1;' " 

$sql=" SELECT * FROM students WHERE name = '' OR 1;'' " 

Always executes! 

//What about $badName==" '; DELETE FROM students where 1 or name=' " 

mysql_real_escape_string() 

a useful function for escaping characters before using a string in an SQL query. 

26


function prepare_insert_sql (& $sql_arr) { 

$sql_fields = implode ( ',', array_keys ( $sql_arr ) ); 

$sql_values = implode ( ',', array_map ( 'escape_string', array_values ( $sql_arr ) ) ); 

return "({$sql_fields}) values ({$sql_values})"; 

} 

Recall INSERT syntax: 

insert into students (name, major, grade) values ('Boris', 'MATH', 89) 

function prepare_update_sql (& $sql_arr) { 

$arr=array(); 

foreach($sql_arr as $key=>$value) { 

$arr[]= $key .'='.escape_string($value); 

} 

return implode(', ', array_values($arr)); 

} 

$sql_arr= array ( 

'name'=>'Boris', 

'major'=>'Math', 

grade=>'89' 

); 

Recall UPDATE syntax: 

update students set name='Boris', major='MATH', grade='89' 

function escape_string($str) { 

return "'" . mysql_real_escape_string($str) . "'"; 

} 

Any Problems 


function add_record(&$HTML) { 

$users_arr=array(); 

$keys='name,major,grade'; 

foreach( explode(',',$keys) as $index => $key ) { 

$users_arr[$key]=$HTML[$key]; 

} 

$HTML= array ( 

'name'=>'Boris', 

'major'=>'Math', 

grade=>'89', 

phone=>'….', 

e‐mail=>'something' 

); 

$result = @mysql_query('INSERT INTO table ' . prepare_insert_sql($users_arr)); 

if ($result) { 

$user_id=mysql_insert_id(); 

@mysql_free_result($result); 

} 

………… 

} 

return $user_id; 

27


Sometimes you have 100+ records that you need to show on more than 1 page 

mysql> select count(studentID) as total_records from students; 

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

| total_records | 

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

| 4 | 

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

In PHP get SQL records for a specific page number $page with $max_list records per page: 

list($total_records) = mysql_fetch_row(@mysql_query('select count(studentID) as ……')); 

$total_pages = ceil($total_records / $max_list); 

$start = ($page‐1) * $max_list; 

$sql_query .= " LIMIT $start, $max_list"; 

Note: this is faster than using MySQL SQL_CALC_FOUND_ROWS and FOUND_ROWS() 


The MySQLi extension provides various benefits with respect to its predecessor. 

It supports all the latest features in MySQL server 4.1 or higher. 

Major features: 

• An object‐oriented interface 

• Procedural interface (all the function names begin with mysqli_ instead of mysql_) 

• Support for the full feature set of the MySQL c‐client library 

• Support for prepared statements 

• Support for multiple statements 

• Support for transactions 

• Enhanced debugging support 

• Embedded server support 

Advantages: 

• Maintainable 

• Similar Syntax 

• New Interface 

• Advanced Options 

• Speed 

• Security 

http://www.php.net/manual/en/book.mysqli.php 

28


MySQLi: Dual Procedural and Object‐Oriented interface 

connect_errno) { 

echo "Failed to connect to MySQL: " . $mysqli‐>connect_error; 

exit; 

} 

If ( $result = $mysqli‐>query("SELECT name, major from students where studentID='10147'") ) { 

$row = $result‐>fetch_assoc(); 

echo $row['name']; 

$result‐>close(); 

} 

> 

http://php.net/manual/en/mysqli.quickstart.dual‐interface.php 

// close database connection 

mysqli_close($mysqli); 

// close database connection 

$mysqli‐>close(); 

else { 

echo mysqli_error(); 

} 

else { 

echo mysqli‐>error; 

} 

MySQLi: Prepared Statements 


Using this new feature, available in MySQLi, it is possible to create queries that are: 

• More secure 

• Have better performance 

• More convenient to write 

Two types of Prepared Statements: 

• Bound Parameter 

• Bound Result 

The '' placeholders can be used in most places that could have literal data. 

A query could be transformed from: 

SELECT name, major FROM students WHERE studentID = '10147'; 

to: 

SELECT name, major FROM students WHERE studentID = ; 

http://www.php.net/manual/en/mysqli.quickstart.prepared‐statements.php 

No quotes around '' 

29


Bound Parameter Prepared Statements 

• A Query template is created and sent to the MySQL server 

• MySQL server validates it, stores it and returns a special handle for future use 

• When a query needs to be executed, data to fill in the template is sent to the server 

• A complete query is formed and then executed 

Advantages 

• The body of the query is sent only once, later only data to fill in are sent 

• Most of the work required to validate and parse the query only needs to be done a single 

time, instead of each time the query is executed. 

• The data for the query does not need to be passed through a function like 

mysql_real_escape_string() 

to ensure that no SQL injection attacks occur. Instead, the sent data is handled safely by 

server when it is combined with the prepared statement. 



Example 1: 

$stmt = $mysqli‐>stmt_init(); // create a prepared statement 

if( $stmt = $mysqli‐>prepare("INSERT INTO students VALUES ('', , , )") ){ 

$name ='Boris'; 

$major ='MATH'; Parameters to be passed by reference 

$grade = 89; 

$stmt‐>bind_param('ssi', $name, $major, $grade); 



} 

/* execute prepared statement */ 

$stmt‐>execute(); 

echo $stmt‐>affected_rows. " row inserted.\n"; 

/* alternative output */ 

printf("%d row inserted.\n", $stmt‐>affected_rows); 

/* close statement and connection */ 

$stmt‐>close(); 

BIND Type 

i 

d 

b 

s 

COLUMN Type 

All INT types 

DOUBLE and FLOAT 

BLOBs 

All other types 


http://www.php.net/manual/en/mysqli‐stmt.bind‐param.php 

30


Example 2: 

$stmt = $mysqli‐>stmt_init(); 

if( $stmt = $mysqli‐>prepare("SELECT name, grade FROM students where studentID =") ){ 

$IDs= array('10147', '10148'); 

$stmt‐>bind_param('i', $studentID); 

} 

foreach($IDs as $studentID) { 



$result= $stmt‐>get_result(); 

/* fetch values: */ 

while ($row = $result‐>fetch_assoc()) { 

printf ("Name: %s , Grade: %d ', $row['name'], $row['grade']); 

} 

} 


Can we simplify this 




StudentID name major Grade 



Bound Result Prepared Statements 

• Allow the value of variables in a PHP script to be tied to the value of fields of data in a 

query result set. 

• Create a query 

• Prepare the query 

• Ask the MySQL server to execute the query 

• Bind PHP variables to columns in the query result 

• Request that a new row of data be loaded into the bound variables. 

It is possible to use bound parameters and bound results together in a single prepared statement. 


31


Example: 

$stmt = $mysqli‐>stmt_init(); 

if( $stmt = $mysqli‐>prepare("SELECT name, grade from students limit 5") ){ 





/* bind variables to prepared statement */ 

$stmt‐>bind_result($name, $grade); 


while ($stmt‐>fetch()) { 

printf ("Name: %s , Grade: %d ', $name, $grade); 

} 

} 






Using Bound Parameters and Bound Results together: 

$stmt = $mysqli‐>stmt_init(); // create a prepared statement 

if( $stmt = $mysqli‐>prepare("SELECT name, grade FROM students where major =") ){ 

$major ='MATH'; 

$stmt‐>bind_param('s', $major); 


/* bind variables to prepared statement */ 

$stmt‐>bind_result($name, $grade); 


while ($stmt‐>fetch()) { 

printf ("Name: %s , Grade: %d ', $name, $grade); 

} 



} 



http://www.php.net/manual/en/book.mysqli.php 

32


Persistent connections are links that do not close when the execution of your script ends. 

When a persistent connection is requested, PHP checks if there's already an identical persistent 

connection (that remained open from earlier) ‐ and if it exists, it uses it. 

To use in PHP: mysql_pconnect(…) , mysqli_connect("p:example.com", ….) 

In reality, persistent connections are evil ! 

1) they can be left in unpredictable states by clients. For example, a table lock might be activated before 

a client terminates unexpectedly. A new client process reusing this persistent connection will get the 

connection "as is". 

2) In PHP is used as a 'CGI' wrapper, an instance of the PHP interpreter is created and destroyed for every 

PHP page. Because it is destroyed after every request, any resources that it acquires (such as a link to 

an SQL database server) are closed when it is destroyed. Hence, persistent connections don't persist. 

3) In multi‐process environment if the same client makes a second request to the server, it may be 

served by a different child process than the first time. 

4) If you have 20 different child processes that ran a script that made a persistent connection to your 

MySQL server, you'd be keeping active 20 different connections 

http://www.php.net/manual/en/features.persistent‐connections.php 

When do we need 

mysql_close() 

Good part: 

Can reduce overhead when you create a link to remote MySQL server. 

They cause the PHP child process to simply connect only once for its entire lifespan, instead of every 

time it processes a page that requires connecting to the MySQL server. 


Normalization was first proposed by Codd as an integral part of the relational model. 

It encompasses a set of best practices designed to eliminate the duplication of data, 

which in turn prevents data manipulation anomalies and loss of data integrity. 

The most common form of normalization applied to databases are called the 

normal forms. 

Example: What's wrong with this database 

Title Author1 Author2 ISBN Subject Pages Publisher 

Database 

System 

Concepts 

Abraham 

Silberschatz 

Henry F. 

Korth 

0072958863 

MySQL, 

Computers 

1168 McGraw-Hill 

Operating 

System 

Concepts 

Abraham 

Silberschatz 

Henry F. 

Korth 

0471694665 Computers 944 McGraw-Hill 

33


Database normalization is also the process in which a database structure is free 

from any uncertainties like update, insertion, and deletion incidences. 

In order to normalize a database it must be designed in the third normal form. In 

the third normal form, all data will be secured, and only certain areas of the table 

are subjected to any change. 

There are three major problems encountered in database normalization and they 

are: the update anomaly, the insertion anomaly, and the deletion anomaly. 

Normalization is criticized because it increases complexity and processing overhead 

required to join multiple tables representing what are conceptually a single item. 


Title Author1 Author2 ISBN Subject Pages Publisher 

Database 

System 

Concepts 

Abraham 

Silberschatz 

Henry F. 

Korth 

0072958863 

MySQL, 

Computers 


This table is not very efficient with storage. 

This design does not protect data integrity. 

Third, this table does not scale well. 

Operating 

System 

Concepts 

Abraham 

Silberschatz 

Henry F. 

Korth 


• we have more than one author field, 

• subject field contains more than one piece of information. 

With more than one value in a single field, it would be very difficult to search for all books 

on a given subject. 

First Normal Form (1NF) sets the very basic rules for an organized database: 

Eliminate duplicative columns from the same table. 

Create separate tables for each group of related data. 

Identify each row with a unique column or set of columns (the primary key). 

34


What about this table 

Book Table 

Title Author ISBN Subject Pages Publisher 

Database System 

Concepts 

Abraham 

Silberschatz 

0072958863 MySQL 1168 McGraw-Hill 


Concepts 

Operating System 

Concepts 

Henry F. Korth 0072958863 Computers 1168 McGraw-Hill 



Concepts 

Abraham 

Silberschatz 


We now have two rows for a single book. 

We need to separate the data into separate tables: 

• Author table 

• Subject table 

Problems 


Title Author ISBN Subject Pages Publisher 


Concepts 


Concepts 


Concepts 


Concepts 

Abraham 

Silberschatz 

0072958863 MySQL 1168 McGraw-Hill 



Abraham 

Silberschatz 


Book Table 

Subject Table 

Subject_ID Subject 

1 MySQL 

2 Computers 

Author Table 

Author_ID Last Name First Name 

1 Silberschatz Abraham 

2 Korth Henry 

ISBN Title Pages Publisher 

0072958863 

0471694665 

What did we achieve 


Concepts 


Concepts 



35


Book Table 


0072958863 

0471694665 


Concepts 


Concepts 



Subject Table 


1 MySQL 

2 Computers 

Author Table 



2 Korth Henry 

Each table has a primary key, used for joining tables together when querying the data. 

A primary key value must be unique with in the table (no two books can have the 

same ISBN number), and a primary key is also an index, which speeds up data retrieval 

based on the primary key. 

How to define relationships between the tables 


Subject Table 

Author Table 



1 MySQL 


2 Computers 

Book Table 

2 Korth Henry 


0072958863 Database System Concepts 1168 McGraw-Hill 

0471694665 Operating System Concepts 944 McGraw-Hill 

Book_Author Table 

Book_Subject Table 

ISBN 

Subject_ID 

ISBN 

Author_ID 

0072958863 1 

0072958863 1 

0072958863 2 

0072958863 2 

0471694665 2 

0471694665 1 

0471694665 2 

Through Primary keys define relationships between the tables. 

36


Subject Table 

Author Table 



1 MySQL 


2 Computers 

2 Korth Henry 

Book Table 




ISBN 

Subject_ID 

0072958863 1 

0072958863 2 

0471694665 2 



ISBN 

Author_ID 

0072958863 1 

0072958863 2 

0471694665 1 

0471694665 2 

Here we have a one‐to‐many relationship between the Book table and the Publisher. 

A book has only one publisher, and a publisher will publish many books. 

When we have a one‐to‐many relationship, we place a foreign key in the Book Table, pointing to the 

primary key of the Publisher Table. 

Second Normal Form (2NF) requires that database doesn't have any data in a table with a 

composite key that does not relate to all portions of the composite key. 


First Normal Form deals with redundancy of data across a horizontal row. 

Second Normal Form (or 2NF) deals with redundancy of data in vertical columns. 

The normal forms are progressive, so to achieve Second Normal Form, the tables 

must already be in First Normal Form. 

Requirements for Second Normal Form (2NF): 

• Meet all the requirements of the First Normal Form. 

• Remove subsets of data that apply to multiple rows of a table and place them in separate tables. 

• Create relationships between these new tables and their predecessors through the use of foreign keys. 

37


Subject Table 





Can't have 'McGraw‐Hill' as a key 

Author Table 


Book Table 

ISBN Title Pages Publisher_ID 

0072958863 

0471694665 


Concepts 


Concepts 

1168 1 

944 1 

Publisher Table 

Publisher_ID Publisher Name 

1 McGraw‐Hill 


Third Normal Form goes one step further: 

• Meet all the requirements of the second normal form. 

• Remove columns that are not dependent upon the primary key. 

• All of the non‐primary key attributes are mutually independent 

Publisher Table 

Publisher_ID Name Address1 City State Zip 

1 

Sams 

Publishing 

800 East 96th 

Street 

Indianapolis Indiana 46240 

Publisher_ID Name Address Zip 

1 Sams Publishing 800 East 96th Street 46240 

Zip City State 

Problem 

46240 Indianapolis Indiana 

38


Transitive relation: 

In mathematics, a binary relation R over asetX is transitive if whenever an 

element a is related to an element b, and b is in turn related to an 

element c, then a is also related to c. 

Example: A> B and B>C then A>C 

Transitive dependency: 

A functional dependency which holds by virtue of transitivity. Conditions: 

1. A B 

2. Not the case that B A 

3. B C 

Then A C 

3NF excludes certain types 

of transitive dependencies 

Example: 

1. {Book} {Author} 

2. {Author} does NOT {Book} 

3. {Author} {AuthorNationality} 

( here means 'knowing') 

{Book} {AuthorNationality} 

IF we know the book, we know Author's Nationality 

Both 'Author' and 'AuthorNationality' are non‐key attributes 


No transitive 

dependency 

between nonkey 

attributes 

All determinants 

are candidate 

keys - Single 

multivalued 

dependency 

First Normal Form (1NF) 

Second Normal Form (2NF) 

Third Normal Form (3NF) 

Boyce‐Codd Normal Form (BCNF) 

Fourth Normal Form (4NF) 

Fifth Normal Form (5NF) 

Boyce- 

Codd 

and 

Higher 

Functional 

dependency 

of nonkey 

attributes on 

the primary 

key - Atomic 

values only 

Full 

Functional 

dependeny 

of nonkey 

attributes 

on the 

primary key 

39


A fully normalized database schema can fail to provide adequate system 

response time due to excessive table join operations. 

http://www.siue.edu/~dbock/cmis564/denormal.htm 

1. Perform a detailed view analysis in order to identify situations where an excessive 

number of table joins appears to be required to produce a specific end‐user view. 

Any view requiring more than three joins should be considered as a candidate for 

denormalization. 

2. Reduce the number of foreign keys in order to reduce index maintenance during 

insertions and deletions. Reducing foreign keys is closely related to reducing the 

number of relational tables. 

3. The ease of data maintenance provided by normalized table structures must also be 

provided by the denormalized schema. Thus, a satisfactory approach would not require 

excessive programming code (triggers) to maintain data integrity and consistency. 


Hillyer Mike, MySQL AB. An Introduction to Database Normalization, 

http://babanski.com/files/MySQL‐intro‐to‐database‐normalization.pdf 

Microsoft. Description of the database normalization basics, 

http://support.microsoft.com/kb/283878 

Wikipedia. Database Normalization. 

http://en.wikipedia.org/wiki/Database_normalization.html 

40


mysql> select * from demo_people; 

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

| name | phone | pid | 

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

| Mr Brown | 01225 708225 | 1 | 

| Ms Smith | 01225 899360 | 2 | 

| Mr Pullen | 01380 724040 | 3 | 

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

mysql> select * from demo_property; 

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

| spid | pid | selling | 

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

| 1 | 1 | Old House Farm | 

| 2 | 3 | The Willows | 

| 3 | 3 | Tall Trees | 

| 4 | 3 | The Melksham Florist | 

| 5 | 4 | Dun Roamin | 

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

Cross‐Join: select * from TABLE1, TABLE2 

We end up with all the possible combinations 

Person number 1 is selling 

property number 1 – Old House Farm 

Person number 2 doesn't sell anything 

Person number 3 is selling: 

property number 2 – The Willows 

property number 3 – Tall Trees 

property number 4 – The Melksham Florist 

Person number 4 is selling 

property number 5 – Dun Roamin. 

pid = person ID 

spid = selling property ID 

Worst join ever! 


Cross‐Join: select * from TABLE1, TABLE2 

We end up with all the possible combinations 

Worst join ever! 

mysql> select * from demo_people,demo_property; 

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

| pid | phone | name | spid | pid | selling | 

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

| 1 | 01225 708225 | Mr Brown | 1 | 1 | Old House Farm | 

| 2 | 01225 899360 | Ms Smith | 1 | 1 | Old House Farm | 

| 3 | 01380 724040 | Mr Pullen | 1 | 1 | Old House Farm | 

| 1 | 01225 708225 | Mr Brown | 2 | 3 | The Willows | 

| 2 | 01225 899360 | Ms Smith | 2 | 3 | The Willows | 

| 3 | 01380 724040 | Mr Pullen | 2 | 3 | The Willows | 

| 1 | 01225 708225 | Mr Brown | 3 | 3 | Tall Trees | 

| 2 | 01225 899360 | Ms Smith | 3 | 3 | Tall Trees | 

| 3 | 01380 724040 | Mr Pullen | 3 | 3 | Tall Trees | 

| 1 | 01225 708225 | Mr Brown | 4 | 3 | The Melksham Florist | 

| 2 | 01225 899360 | Ms Smith | 4 | 3 | The Melksham Florist | 

| 3 | 01380 724040 | Mr Pullen | 4 | 3 | The Melksham Florist | 

| 1 | 01225 708225 | Mr Brown | 5 | 4 | Dun Roamin | 

| 2 | 01225 899360 | Ms Smith | 5 | 4 | Dun Roamin | 

| 3 | 01380 724040 | Mr Pullen | 5 | 4 | Dun Roamin | 

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

Cross joins are also called Cartesian products 

41


JOIN / INNER JOIN / CROSS JOIN (all are syntactic equivalents) : 

We get all records that match in the appropriate way in the two tables. 

Records in both incoming tables that do not match are not reported: 

mysql> select name, phone, selling from demo_people 

join demo_property on demo_people.pid = demo_property.pid; 

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

| name | phone | selling | 

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

| Mr Brown | 01225 708225 | Old House Farm | 

| Mr Pullen | 01380 724040 | The Willows | 

| Mr Pullen | 01380 724040 | Tall Trees | 

| Mr Pullen | 01380 724040 | The Melksham Florist | 

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

on demo_people.pid = demo_property.pid 

can be replaced with 

using (demo_people.pid) 

Record pid=2 is not reported (No properties): 

| Ms Smith | 01225 899360 | 2 | 

Note: we don't have OUTER JOIN !!! 


LEFT JOIN / LEFT OUTER JOIN: 

We get all records that match in the same way and IN ADDITION 

we get an extra record for each unmatched record in the left table of the join 

(Example: we want to ensure that every PERSON gets a mention). 


left join demo_property on demo_people.pid = demo_property.pid; 

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


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


| Ms Smith | 01225 899360 | NULL | 




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

Note: we don't have LEFT INNER JOIN !!! 

42


RIGHT JOIN / RIGHT OUTER JOIN: 

We get all records that match in the same way and IN ADDITION 

we get an extra record for each unmatched record in the right table of the join 

(Example: we want to ensure that every PROPERTY gets a mention). 


right join demo_property on demo_people.pid = demo_property.pid; 

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


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





| NULL | NULL | Dun Roamin | 

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

Note: we don't have RIGHT INNER JOIN !!! 


MyISAM storage engine does not support foreign keys. You need to use InnoDB engine. 

• employee: a table of company employees where each member is assigned a unique ID 

• borrowed: a table of borrowed books. Every record will reference a borrower’s employee ID. 

CREATE TABLE employee ( 

id smallint(5) unsigned NOT NULL, 

firstName varchar(30), 

lastName varchar(30), 

PRIMARY KEY (id), 

KEY idx_lastName (lastName) 

) ENGINE=InnoDB; 

We want to add Foreign Key Constraint called 'FK_borrowed' 

http://dev.mysql.com/doc/refman/5.5/en/innodb‐foreign‐key‐constraints.html 

CREATE TABLE borrowed ( 

ref int(10) unsigned NOT NULL auto_increment, 

employeeid smallint(5) unsigned NOT NULL, 

book varchar(50), 

PRIMARY KEY (ref) 

) ENGINE=InnoDB; 

ALTER TABLE borrowed 

ADD CONSTRAINT FK_borrowed FOREIGN KEY (employeeid) REFERENCES employee(id) 

ON UPDATE CASCADE 

ON DELETE RESTRICT 

The FOREIGN KEY clause is specified in the child table. 

CASCADE: Delete or update the row from the parent table, and automatically delete or update the matching rows in the child table. 

RESTRICT: Rejects the delete or update operation for the parent table (default if not set otherwise). 

43


Remember that parent table (employees) must be added/populated with data first: 

employee 

borrowed 

id firstName lastName 

ref employeeid book 

1 John Smith 

1 1 Simply SQL 

2 Laura Jones 

2 1 Ultimate HTML Reference 

3 1 Ultimate CSS Reference 

3 Jane Green 

4 2 Art of JavaScript 

SELECT book FROM borrowed 

JOIN employee ON employee.id=borrowed.employeeid 

WHERE employee.lastname='Smith'; 

UPDATE employee SET id=22 WHERE id=2; 

No need to update 'borrowed' table directly!! 

What about this 

DELETE FROM employee WHERE id=1; 

Won't work with RESTRICT; deletes records from borrowed with CASCADE 

Result: 

Simply SQL 

Ultimate HTML Reference 

Ultimate CSS Reference 

borrowed 

ref employeeid book 

1 1 Simply SQL 

2 1 Ultimate HTML Reference 

3 1 Ultimate CSS Reference 

4 22 Art of JavaScript 


MySQL 5.5 Reference Manual 

http://dev.mysql.com/doc/refman/5.5/en/index.html 

44

1 1 CS3336a, Alex Babanski CS3336a, Alex Babanski &lt;?php echo ...

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?

1 1 CS3336a, Alex Babanski CS3336a, Alex Babanski <?php echo ...