Relational Databases

and MySQL
Charles Severance
www.php-intro.com
 Relational Databases
Relational databases model data by storing
rows and columns in tables. The power of the
relational database lies in its ability to
efficiently retrieve data from those tables and
in particular where there are multiple tables
and the relationships between those tables
involved in the query.

http://en.wikipedia.org/wiki/Relational_database
 Terminology
• Database - Contains many tables

• Relation (or table) - contains tuples and attributes

• Tuple (or row) - is a set of fields it generally represents an “object” like

a person or a music track

• Attribute (also column or field) - One of possibly many elements of

data corresponding to the object represented by the row
 A relation is defined as a set of tuples that have the same attributes. A tuple
usually represents an object and information about that object. Objects are
typically physical objects or concepts. A relation is usually described as a table,
which is organized into rows and columns. All the data referenced by an attribute
are in the same domain and conform to the same constraints. (wikipedia)
Columns / Attributes

Rows /
Tuples

Tables / Relations
 Application Structure
Application
End Database
Software (i.e. SQL
User Data Model
PHP)

SQL

Developer
Database
Tools (i.e.
DBA
phpMyAdmin)
 SQL
• Structured Query Language is the language we use to issue commands
to the database

• Create a table

• Retrieve some data

• Insert data

• Delete data
http://en.wikipedia.org/wiki/SQL
 Common Database Systems
• Three Major Database Management Systems in wide use

• Oracle - Large, commercial, enterprise-scale, very very tweakable

• MySql - Simpler but very fast and scalable - commercial open source

• SqlServer - Very nice - from Microsoft (also Access)

• Many other smaller projects, free and open source

• HSQL, SQLite, Postgress, ...

 Command Line

• After Control Panel is Running...

• Macintosh

• /Applications/MAMP/Library/bin/mysql -uroot –proot

• Windows

• c:\xampp\mysql\bin\mysql.exe -u root -p
 Your first MySQL Command

• Kind of like

• print 'hello world'

• show databases;
If this does not work, stop and
figure out why.

Some of these are part of

MySQL and store internal
data - don't mess with them.
Creating a Database
Command Line:

CREATE DATABASE People;

USE People;
 Start Simple - A Single Table
• Lets make a table of Users in our People database

• Two columns - Name and an E-Mail

CREATE TABLE Users(

name VARCHAR(128),
email VARCHAR(128)
)

DESCRIBE Users;
 SQL Insert

• The Insert statement inserts a row into a table

INSERT INTO Users (name, email) VALUES ('Chuck', 'csev@umich.edu')

INSERT INTO Users (name, email) VALUES ('Sally', 'sally@umich.edu')
INSERT INTO Users (name, email) VALUES ('Somesh', 'somesh@umich.edu')
INSERT INTO Users (name, email) VALUES ('Caitlin', 'cait@umich.edu')
INSERT INTO Users (name, email) VALUES ('Ted', 'ted@umich.edu')
 SQL Delete

• Deletes a row in a table based on a selection criteria

DELETE FROM Users WHERE email='ted@umich.edu'

 SQL: Update

• Allows the updating of a field with a where clause

UPDATE Users SET name='Charles' WHERE email='csev@umich.edu'

 Retrieving Records: Select

• The select statement retrieves a group of records - you can either

retrieve all the records or a subset of the records with a WHERE clause

SELECT * FROM Users

SELECT * FROM Users WHERE email='csev@umich.edu'

 Sorting with ORDER BY

• You can add an ORDER BY clause to SELECT statements to get the

results sorted in ascending or descending order

SELECT * FROM Users ORDER BY email

SELECT * FROM Users ORDER BY name

 The LIKE clause
• We can do wildcard matching in a WHERE clause using the LIKE
operator

SELECT * FROM Users WHERE name LIKE '%e%'

 The LIMIT Clause
• The LIMIT clause can request the first "n" rows, or the first "n" rows after
some starting row. Note: the first row is zero, not one

• WHERE and ORDER BY clauses happen *before* the LIMIT is applied

• The limit can be a count or a starting row and count (starts from 0)

SELECT * FROM Users ORDER BY email DESC LIMIT 2;

SELECT * FROM Users ORDER BY email LIMIT 1,2;
 Counting Rows with SELECT

• You can request to receive the count of the rows that would be
retrieved instead of the rows

SELECT COUNT(*) FROM Users;

SELECT COUNT(*) FROM Users WHERE email='csev@umich.edu'
 SQL Summary
INSERT INTO Users (name, email) VALUES ('Ted', 'ted@umich.edu')

DELETE FROM Users WHERE email='ted@umich.edu'

UPDATE Users SET name='Charles' WHERE email='csev@umich.edu'

SELECT * FROM Users WHERE email='csev@umich.edu'

SELECT * FROM Users ORDER BY email

SELECT * FROM Users WHERE name LIKE '%e%'

SELECT * FROM Users ORDER BY email LIMIT 1,2;

SELECT COUNT(*) FROM Users WHERE email='csev@umich.edu'

 This is not too exciting (so far)

• Tables pretty much look like big fast programmable spreadsheet with
rows, columns, and commands

• The power comes when we have more than one table and we can
exploit the relationships between the tables
 Looking at Data Types

• Text fields (small and large)

• Binary fields (small and large)

• Numeric fields

• AUTO_INCREMENT fields
 String Fields

• Understand character sets and indexable for searching

• CHAR allocates entire space (faster for small strings where length is
known)

• VARCHAR allocates variable amount of space depending on the data

length (less space)
 Text Fields
• Have a character set - paragraphs or HTML pages

• TINYTEXT up to 255 characters

• TEXT up to 65K

• MEDIUMTEXT up to 16M

• LONGTEXT up to 4G

• Generally not used with indexing or sorting - and only then limited to a
prefix
 Binary Types (rarely used)
• Character = 8 - 32 bits of information depending on character set

• Byte = 8 bits of information

• BYTE(n) up to 255 bytes

• VARBINARY(n) up to 65K bytes

• Small Images - data

• Not indexed or sorted

Binary Large Object (BLOB)
• Large raw data, files, images, word documents, PDF, Movies, etc etc..

• No translation, indexing or character set

• TINYBLOB(n) - up to 255

• BLOB(n) - up to 65K

• MEDIUMBLOB(n) - up to 16M

• LONGBLOB(n) - up to 4G
http://www.youtube.com/watch?v=XhyRpvgm03g
 Integer Numbers
• Numbers are very efficient, take little storage and are easy to process
because CPU's can compare them often with a single instruction

• TINYINT (-128, 128)

• SMALLINT (-32768, +32768)

• INT or INTEGER (2 Billion)

• BIGINT - (10**18 ish)

 Floating Point Numbers

• Floating point numbers can represent a wide range of values but accuracy
is limited

• FLOAT (32-bit) 10**38 with seven digits of accuracy

• DOUBLE (64-bit) 10**308 with 14 digits of accuracy

 Dates

• TIMESTAMP - 'YYYY-MM-DD HH:MM:SS' (1970, 2037)

• DATETIME - 'YYYY-MM-DD HH:MM:SS'

• DATE - 'YYYY-MM-DD'

• TIME - 'HH:MM:SS'

• Built-in MySql function NOW()

 AUTO_INCREMENT

• Often as we make multiple

DROP TABLE Users;
tables and need to JOIN them CREATE TABLE Users (
together we need an integer, user_id INT UNSIGNED NOT NULL
primary key for each row so we AUTO_INCREMENT KEY,
can efficiently add a reference name VARCHAR(128),
to a row in a table, in some email VARCHAR(128)
other table as a foreign key )

DESCRIBE Users;
 MySQL Functions

• Many operations in MySQL need to use the built-in functions (i.e. like
NOW() for dates)

• http://dev.mysql.com/doc/refman/5.0/en/string-functions.html

• http://dev.mysql.com/doc/refman/5.0/en/date-and-time-functions.html
 Indexes
• As a table gets large (they always do) scanning all the data to find a
single row becomes very costly

• When drchuck@gmail.com logs into FaceBook, they must find my

password amongst 500-million users

• There are techniques to greatly shorten the scan as long as you create
data structures and maintain those structures - like shortcuts

• Hashes or Trees
 MySQL Index Types
• PRIMARY KEY - Very little space, very very fast, exact match,
requires no duplicates, extremely fast for integer fields

• INDEX - Good for individual row lookup and sorting / grouping

results - works best with exact matches or prefix lookups - can suggest
HASH or BTREE

• FULLTEXT - Costly to maintain on insert of new data, can handle

substrings and the LIKE clause
 FULLTEXT Details
• FULLTEXT indexes can be used only with tables that use the
MyISAM engine. (ALTER TABLE tablename ENGINE = MyISAM;)

• FULLTEXT indexes can be created for CHAR, VARCHAR, and TEXT

columns only.

• For large data sets, it is much faster to load your data into a table that
has no FULLTEXT index and then create the index than to load data
into a table that has an existing FULLTEXT index.
 Hashes
A hash function is any algorithm or subroutine
that maps large data sets to smaller data sets,
called keys. For example, a single integer can
serve as an index to an array (cf. associative
array). The values returned by a hash function
are called hash values, hash codes, hash sums,
checksums or simply hashes.
Hash functions are mostly used to accelerate
table lookup or data comparison tasks such as
finding items in a database...

http://en.wikipedia.org/wiki/Hash_function
 B-Trees
A B-tree is a tree data structure that keeps data sorted and allows searches,
sequential access, insertions, and deletions in logarithmic amortized time. The
B-tree is optimized for systems that read and write large blocks of data. It is
commonly used in databases and file systems.

http://en.wikipedia.org/wiki/B-tree
 Specifying Indexes
ALTER TABLE Users ADD INDEX ( name ) USING BTREE

DROP TABLE Users;

CREATE TABLE Users (

user_id INT UNSIGNED NOT NULL
AUTO_INCREMENT KEY,
name VARCHAR(128),
email VARCHAR(128),
INDEX ( name )
);
 Summary

• SQL allows us to describe the shape of data to be stored and give many
hints to the database engine as to how we will be accessing or using the
data

• SQL is a language that provides us operations to Create, Read, Update,

and Delete (CRUD) our data in a database
 Acknowledgements / Contributions
Continue new Contributors and Translators here
These slides are Copyright 2010- Charles R. Severance (www.dr-
chuck.com) as part of www.php-intro.com and made available
under a Creative Commons Attribution 4.0 License. Please
maintain this last slide in all copies of the document to comply with
the attribution requirements of the license. If you make a change,
feel free to add your name and organization to the list of
contributors on this page as you republish the materials.

Initial Development: Charles Severance, University of Michigan

School of Information

Insert new Contributors and Translators here including names and

dates