MySQL

The MySQL database server is the

world's most popular open source database.

MySQL 5.1, the latest production-ready

release includes numerous enhancements

that improve performance,

internationalization, and the ability to embed

the MySQL Server with other hardware and

software solutions.

How to Install the MySQL Database

Server on Your Windows PC

Log into the computer as an administrator. This will

give you administrator rights, which will make the

installation smoother. Note that, once installed, the

program doesn’t need to be run as an administrator.

Download the free MySQL Server Community

Edition. Be sure to download a version that includes a

Windows Installer. Save the file on your Windows

Desktop.If you’re not sure which version to select,

download MySQL Installer for Windows.

Double-click the downloaded file. The installation file

comes as a .zip file, so double-clicking it should initiate

your unzipping software and take you to an archive

folder.

Double-click Setup.exe. (It should be the only file

inside your archive.) This will initialize the setup

process.

Click Next. This begins the setup.

Click Custom > Next. This will enable you to specify where

you want to install MySQL. If you have Apache installed in

C:\Server, you will want to install MySQL in the same

directory.In the next window, highlight MySQL Server, and

then click the Change.

In the next window, in the text box Folder Name, change

the directory toC:\Server\MySQL\ exactly as it’s written

here and then click OK.

On the next window, click Next. Now MySQL is ready to

install.

Click Install. Wait while the program self-installs.

Click Skip Sign-Up and then Next. Once the

installation is complete, you will be presented with

a MySQL Sign-Up window. Skip signing up with

MySQL for now since you can sign up later if you

like. Once you’ve skipped, your new dialogue box

should sayWizard Completed.

Configure MySQL. Leave the check box Configure the

MySQL Server Now checked and click Finish.

Click Next. This will initialize the configuration setup.

Check Standard Configuration and then click Next. This

is the default configuration and is recommended for most

users.

Make sure Install As Windows Service and Launch the

MySQL Server Automatically are checked, then click

Next.

Create a root password. Type in what you want your root

password to be and make sureEnable root access from

remote machines is checked. Make sure you choose a

difficult to guess password and 'write it down so you don't

forget it. Click Next.

Click Execute. This will start the MySQL server. After

MySQL has done its thing, clickFinish.

From the Windows task bar, go to Start > All Programs

> MySQL > MySQL Server 4.x > MySQL Command line

client. This will open a command window asking you for a

password.

Enter your root password and hit Enter. This should

initiate the program.

How to use MySQL Administrator to

backup a database

Step 1. Enter the login details for the MySQL connection. The Server

Host should be your domain name and you can use your cPanel login

details in order to access all databases in your account. Alternatively,

you can use the MySQL username you have created through the MySQL

Databases tool in your cPanel in order to connect to the database that it

has access to. You should leave the Port setting to its default value -

3306.

Once you have entered your credentials, click on the OK button.

Step 2. Once you have logged in, a screen with the MySQL

server status will appear. If you are using the application on

a local server you will be able to execute administrative

tasks like restarting the MySQL server for example. On a

Shared hosting account, however, you can only create

backups and restore your databases with this application.

Step 3. To create a backup of your database, click on the

"Backup" button from the left menu. Then click on the "New

Project" button, set the name for your backup and click on

the "Save Project" button.

Step 4. Once you have created a project, you have to select which

databases you want to backup. To do this, mark the database from the

left column that shows the available databases. Next, click on the right-

pointing arrow to mark the database for backup. Once you have done

that, click on the "Execute Backup Now" button in order to start the

backup of your database.

Step 5. The application will ask you where to store the

backup file of your database. Select a suitable location on

your local computer and click on the "Save" button.

How to use MySQL Administrator to

restore a database

Step 1. Click on the "Restore" Button from the left menu. Next, press

the "Open Backup File" button at the bottom of your screen. Locate

and open the .sql file you have previously created using the Backup

option.

Step 2.The MySQL Administrator application will automatically detect

which database should be restored. All you have to do is press the "Start

Restore" button to initiate the backup restore.

Versions of the MySQL

Server

The My SQL Server Instance Configuration Wizard is used to set

up the initial configuration of the My SQL server and set up the My SQL

server as an automatically running Windows service. The service accesses

the mysqld-nt or similar server script to actually run a My SQL server.

MySQL supports a Standard edition, a Max edition and a Debug

edition (rarely used). As you probably noticed when you downloaded the

Windows distribution file, you were not given the option to select an

edition. Windows distribution files, unlike other operating systems, include

all editions in one file, so you do not have to make a decision about

editions until after you install MySQL. Initially, that choice is made for

you by running the MySQL Server Instance Configuration Wizard. There

might come a time, though, when you want to choose a different edition of

the server.

The Windows distribution of MySQL includes

five editions of the MySQL server. These editions can

be divided into the broader categories that you saw

earlier - Standard and Max. The following table

describes the five server editions available in a

MySQL Windows installation.

Server Edition Description

mysqld

This is the basic compiled edition of the

MySQL server. It supports all the basic

features found in a production release of

MySQL. This edition also contains full

debugging support, which means that it

might run more slowly and use more

memory than other editions of the MySQL

server.

mysqld-debug

The binaries are compiled with additional

debug data and are not intended for use in a

production environment.

mysqld-nt

This edition of the MySQL server is

optimized to run on Windows NT, Windows

2000, Windows XP, and Windows Server

2003. In addition, the mysqld-nt server

supports named pipes.

mysqld-max

The mysqld-max server is the Max edition of

the MySQL server. As a result, it includes all

features found in the mysqld server, plus

additional features.

mysqld-max-nt

Like the mysqld-nt server, the mysqld-max-

nt server is optimized to run on Windows NT,

Windows 2000, Windows XP, and Windows

Server 2003, and it supports named pipes.

In addition, because the mysqld-max-nt

server is the Max edition of the MySQL

server, it includes all features found in the

mysqld-nt server, plus additional features.

On variants of Windows (NT, Server 2000, XP, or

Server 2003), we will start with the mysqld-nt

server. If additional features of the Max version

become a need, we can move to Max version later.

The mysqld program is the MySQL server daemon,

though we will rarely interact with it directly. We will use the

daemon through a wrapper script called mysqld_safe. The

mysqld_safe wrapper adds a few extra safety-related logging

features and system- integrity features when the daemon is

started and is the preferred way to start the server.

MySQL installs more than a thousand files and directories on your system. The

location of these files differs depending on the installation mechanism you choose.

The tar ball root directory structure contains the following:

Directory Contents

Bin - Binaries - mysqld server program, all client programs and

tools you will run to use and administer MySQL.

Data - The data files where MySQL reads and writes its data, along

with log files for the server.

Docs - Documentation - HTML and text files pertaining to installed

version.

Include - A set of header files that may be used when writing or

compiling other programs.

Lib - MySQL library files.

Scripts - mysql_install_db script, which is used to install initial data

files and accounts.

Share - SQL scripts for fixing privileges, as well as a set of language

files for using MySQL in a variety of languages.

sql-bench - A set of benchmarking tools included with MySQL.

support-files - Several configuration file examples and other support scripts.

Securing the MySQL Server: Set root Password

After a new installation, anyone can log in as root without a password to MySQL

and have unrestricted privileges to read, change, and delete all databases. For

reasons of security it is absolutely necessary that you give a password for root.

Here are some methods to set or change the root password for a MySQL

installation. That password is normally an empty string at initial installation.

Use SET PASSWORD command:

Code Sample:

SET PASSWORD FOR 'root'@'localhost' =

PASSWORD('abcd1234');

Use mysqladmin

root# mysqladmin -u root password "<password-string>"

if there was already a mysql root password set, change this to:

OS> mysqladmin -u root password <old-password> "<new-

password>“

root# mysqladmin -u root password 'secret'

root# mysqladmin -u root -h your-host-domain password

'secret'

You may see an error Host 'your-host-domain' is not allowed to connect to this

MySQL server'.

This error indicates that MySQL Access-Control database mysql has no domain

name set.

To solve this, we will restart the mysql and,

Update the table mysql.user with an UPDATE command.

Then we change the second root password with mysqladmin. The following lines

summarize the

commands, once with and once without the domain name:

root# mysql -u root -p

Enter password: *******

mysql> USE mysql;

mysql> UPDATE user SET host="<your-host-domain>" WHERE

host="<computer-name>";

mysql> FLUSH PRIVILEGES;

mysql> exit

root# mysqladmin -u root -h computer-name password 'secret'

As seen above, we can also use UPDATE to directly edit the users table

OS> mysql -u root

mysql> use mysql;

mysql> UPDATE user SET Password = PASSWORD('"<new-password>"')

WHERE User = 'root';

mysql> FLUSH PRIVILEGES;

This requires knowing the current password for root user. Alternately, you can

restart mysql as shown:

OS> mysqld --skip-grant-tables user=root

and use method shown above.

Delete Anonymous Accounts

As an important security measure, one should delete all anonymous users. These

are users for whom the user column is empty. In other words, allow only explicitly

registered users in the mysql.user table to log in.

Code Sample:

DELETE FROM user WHERE user = '‘

Creating an Account for Basic Use

One core initial task is setting up a new database and making it available to a

user, who can create tables and fill them with data.

Code Sample:

GRANT ALL ON sakila.* TO sakilaadmin IDENTIFIED BY 'sakila';

GRANT SELECT,UPDATE,DELETE,INSERT ON sakila.* TO

sakilauser

IDENTIFIED BY 'sakila';

Code Explanation

Here, we grant unrestricted access to sakilaadmin user and limited access

to sakila user.

General Information using MySQL Monitor

The MySQL client that ships with the My SQL distribution is named mysql.

Next, we will connect to the server using the MySQL Client mysql, and execute

some simple SQL commands. Run the client from your command prompt by

switching to the bin directory of your My SQL installation:

OS> mysql -u root -p

Password: *****

Code Sample:

SHOW DATABASES;

SHOW TABLES;

SELECT COUNT(*) FROM user;

Configuring My SQL

MySQL reads configuration file(s) when it starts up. If you use the

defaults or an installer, you probably don't need to add anything to the

configuration file. However, if you install MySQL in a nonstandard location or want

the databases to be stored somewhere other than the default, you might need to

edit the configuration file. The configuration file is namedmy.ini or my.cnf. It's

located in your system directory (such as Windows or Winnt) if you are using

Windows or in /etc on Linux, Unix, and Mac.

The configurations file contains several sections and commands for

various components and processes in MySQL. As an example, the following

commands in the mysqld section sometimes need to be reconfigured:

[mysqld]

# The TCP/IP Port the MySQL Server will listen on

port=3306

#Path to installation directory. All paths are

# usually resolved relative to this.

basedir="C:/Program Files/MySQL/MySQL Server 5.0/"

#Path to the database root

datadir="C:/Program Files/MySQL/MySQL Server 5.0/Data/"

The # at the beginning of the line makes the line into

a comment. The basedir line tells the MySQL server

where MySQL is installed. The datadir line tells the

server where the databases are located. You can

change the port number to tell the server to listen for

database queries on a different port.

MySQL Programs and

Executables

This lesson provides a quick reference for the key programs,

options and functions of the key MySQL tools. We discuss the

server mysqld, the command interpreter mysql, and the

administration tools mysqladmin, myisamchk, etc.

MySQL server provides several varieties of programs:

The MySQL server and server startup scripts:

mysqld starts the MySQL database server.

mysqld_safe, mysql.server, and mysqld_multi are server

startup scripts.

mysql_install_db initializes the data directory and the

initial databases.

MySQL Instance Manager monitors and manages

MySQL server instances.

Client programs that access the server:

• mysql is a command-line client for executing SQL statements interactively

or in batch mode.

• mysqladmin is an administrative client.

• mysqlcheck performs table maintenance operations.

• mysqldump and mysqlhotcopy make database backups.

• mysqlimport imports data files.

• mysqlshow displays information about databases and tables.

Utility programs that operate independently of the server:

• myisamchk performs table maintenance operations.

• myisampack produces compressed, read-only tables.

• mysqlbinlog is a tool for processing binary log files.

• my_print_defaults print option values from options files.

• perror displays the meaning of error codes.

•Note: Generally, most MySQL distributions include all of these

programs, except for programs that are platform-specific such as

server startup scripts. The distributions for different operating systems

do not look alike; for example, the RPM distributions are more

specialized - for server, for client and so forth.

The following table provides an overview of the commands discussed in this

section. MySQL Server and Included

Administrative Tools

Mysqld

Is the actual MySQL server. The

program is usually not started directly,

but under Windows as a system service

and under Unix/Linux via an Init-V script

with the help of mysqld_safe .

mysqld_safe

Should be used under Unix/Linux for a

secure server launch.

Mysql

Client-tool that enables interactive

execution of SQL commands.

mysqladmin

Assists in various administrative tasks

(display status, reinput privileges,

execute shutdown, etc.).

MySQL Server and Included

Administrative Tools

Mysqldump

Saves contents of a MySQL database in

a text file.

Mysqlimport

Inputs data into a table from a text file.

Mysqlshow Displays information on databases,

tables, and columns.

Myisamchk

Checks the integrity of MyISAM table

files and repairs them as necessary.

Myisampack

Compresses MyISAM table files for

more efficient read-only access.

Common Options to Commands

Various options can be passed to all commands when they are executed.

As is usual with Unix/Linux, commands can be prefixed with a hyphen (short form) or

two hyphens (full option name). Please note that the short forms of options are case-

sensitive.

The common feature exhibited by the commands introduced in this section

is that they are launched as external programs in a command window (Windows) or

in a command shell (Unix/Linux). The entire operation of these programs is carried

out in text mode and is therefore not what one would term excessively convenient.

However, these commands are very well suited for execution in scripts in the

automation of administrative tasks.

Common Options of the MySQL Server (mysqld) and the MySQL Client Tools

(mysql, mysqladmin, mysqldump, mysqlimport, etc.)

--help - Displays a brief operation introduction.

--print-defaults - Displays default values for options; default values can come from

configuration files or system variables.

--nodefaults - Causes no configuration files to be read at startup.

--defaults-file=filename - Causes only this configuration file to be read at startup.

--defaults-extra-file=filename - First the global configuration file is read, and

then filename, and finally (only under Unix/Linux), the user-specific configuration file.

--port=n - Specifies the TCP/IP port over which communication takes place (usually

3306).

--version - Displays the version number of the program.

Displays the version number of the program.

Common Options of the

MySQL Client Tools

-u <username> --user=username Determines the user name for

registration with MySQL.

-p --password Asks for input of password immediately

after start of the command.

-p<password> --password=xxx Passes the password directly; in

contrast to other options, there can be

no space after - p; this is more

convenient than interactive input of the

password, but it represents a

considerable security risk and thus

should generally be avoided. Under

some operating systems, any user can

see the password by looking at the

process list.

-h hostname --host=hostname Supply the name or IP number of the

computer on which the server is

running (assumed by default to

belocalhost, that is, the local

computer). OS> mysql -h staginghr -u username -p

Enter Password: xxxxxx

For a connection to the MySQL server to be at all possible, the following two options

are generally used at the start of each client command:

OS> mysql -u username -p

Enter Password: xxxxxx

If MySQL is not yet password-secured, then this will work without a password being

specified. We discuss users and setting password for root in other lessons.

If you execute MySQL commands under Windows and create a directory with

options, then instead of the backslash you should use the forward slash (/). If the file

name contains space characters, then put the entire path in quotation marks, as in

the following example: --basedir="C:/Programs/MySQL/MySQL Server 5.0/".

Specifying Options

There are several ways to specify options for MySQL programs:

• Command Line: List the options on the command line following the program

name. This allows for options to be appled to a specific invocation of the

program.

• Options File: List the options in an option file that the program reads when it

starts. This helps by setting options in one place, one time that we want

programs to use each time they run.

• Environment Variables: Set the options via environment variables at the OS

level. This method is useful for options that you want to apply each time the

program runs. In practice, option files are used more commonly for this

purpose.

Options on the Command Line

Program options specified on the command line follow these rules:

• Options are given after the command name.

• An option argument begins with one dash or two dashes, depending on whether it

has a short name or a long name. Many options have both forms. For example, -?

and --help are the short and long forms of the option that instructs a MySQL

program to display its help message.

• Option names are very case sensitive. -v and -V are both legal and have different

meanings. (They are the corresponding short forms of the --verbose and --version

options.)

• Some options follow their name = a value. For example, -h localhost or --

host=localhost indicate the MySQL server host to a client program. The option

value tells the program the name of the host where the MySQL server is running.

• For a long option that takes a value, separate the option name and the value by

an = sign.

• For a short option that takes a value, the option value can immediately follow the

option letter, or there can be a space between: -hlocalhost and -h localhost are

equivalent. An exception to this rule is the option for specifying your MySQL

password. This option can be given in long form as --password=pass_val or as --

password. In the latter case (with no password value given), the program prompts

you for the password. The password option also may be given in short form as -

ppass_val or as -p. However, for the short form, if the password value is given, it

must follow the option letter with no intervening space. The reason for this is that if

a space follows the option letter, the program has no way to tell whether a following

argument is supposed to be the password value or some other kind of argument.

Consequently, the following two commands have two completely different

meanings:

Code Sample:

mysql -usakilaadmin -psakila

mysql -usakilaadmin -p sakila

Code Explanation

The first command instructs mysql to use sakila as password and specifies no

default database.

The second command causes mysql to prompt for the password value and to

use sakila as the default database.

We will see more on setting options in later lessons.

my_print_defaults: Display options from files

The my_print_defaults program displays the options that are present in the

various option groups of option files. The output indicates what options will be used

by programs that read the specified option groups.

For example, the mysqlcheck program reads the [mysqlcheck] and [client] option

groups. The output consists of options, one per line, in the form that they would be

specified on the command line. To see what options are present in those groups in

the standard option files, invoke my_print_defaults like this:

Code Sample:

my_print_defaults mysqlcheck client

Code Explanation

List options present in the client group:

shell> my_print_defaults mysqlcheck client

--user=sakiladmin

--password=****

--host=localhost

--port=3306

Here are the options one can use with the my_print_defaults program:

--help, -?:Display a help message and exit.

--config-file=file_name,--defaults-file=file_name,-c file_name:Read only the

given option file.

--debug=debug_options, -#debug_options: Write a debugging log.

The debug_options string often is 'd:t:o,file_name'.The default

is 'd:t:o,/tmp/my_print_defaults.trace'.

--defaults-extra-file=file_name, --extra-file=file_name, -e file_name :Read this

option file after the global option file but (on Unix) before the user option file.

--defaults-group-suffix=suffix,-g suffix:In addition to the groups named on the

command line, read groups that have the given suffix.

--no-defaults, -n:Return an empty string.

--verbose, -?, -v:Verbose mode. Print more information about what the

program does.

--version, -V:Display version information and exit.

Code Sample:

my_print_defaults --

debug=d:t:o,my_print_defaults.trace --verbose mysqlcheck

client

Code Explanation

List options present in the client group in a trace file.

perror: Explain Error Codes

For most system errors, MySQL displays, in addition to an

internal text message, the system error code in one of the

following styles:

Syntax

message ... (errno: #)

message ... (Errcode: #)

You can discover the meaning of the error code by viewing your system's

documentation for or by using the perror utility. The perror program prints a

description for a system error code or for a storage engine (table handler)

error code.

The syntax of perror is shown below with an example:

Syntax

shell> perror [options] errorcode(s)

Code Sample:

perror 12 41 42;

This results in the following:

OS error code 12: Not enough space

OS error code 41: Directory not empty

OS error code 42: Illegal byte sequence

Note: The meaning of system error messages may be dependent

on your operating system. It is possible for a given error code to

have different meanings on different operating systems.

Here are the options supported by the perror command:

--help, --info,-I, -?: Display a help message and exit.

--ndb: Print the error message for a MySQL Cluster error

code.

--silent, -s: Silent mode. Print only the error message.

--verbose, -v: Verbose mode. Print error code and

message (default behavior).

--version, -V: Display version information and exit.

Overview of User

Interfaces

MySQL provides three main GUI client programs for use with

MySQL Server.

EMS SQL Manager for MySQL is a high performance tool for

MySQL database administration and development.

SQL Maestro for MySQL Overview: is the premier MySQL

admin tool for MySQL database management, control and

development.

SQLyog MySQL GUI is the most powerful MySQL manager

and admin tool, combining the features of MySQL Query

Browser, Administrator, phpMyAdmin and other MySQL Front

Ends and MySQL GUI tools in a single intuitive interface.

MySQL Query Browser: This graphical tool is used for creating,

executing, and optimizing queries on MySQL databases.

MySQL Administrator: This tool is used for administering

MySQL servers, databases, tables, and user accounts.

MySQL Migration Toolkit: This tool helps you migrate schemas

and data from other relational database management systems

for use with MySQL.

Other MySQL GUI Tools

MySQL Query Browser

The main purpose of the MySQL Query Browser is to help you in

composing and testing SQL commands. Additionally, the program offers some

auxiliary functions: you can insert data into tables, alter data in tables, test regular

expressions (for the SQL operator REGEX), read MySQL help texts, etc.

To become familiar with the MySQL Query Browser, input a simple SQL command.

SQL keywords are shown automatically in color. Execute the command with the

EXECUTE button.

The first window in Query Browser provides you the capability of writing your scripts

and seeing the results in the window. You can manage your schemas, manage

users, etc.

Query browser is divided into many sections for achieving these tasks.

• Query Area - This area allows for inputting your desired query.

• Result Area - This area shows the results after the query is executed.

• Query Toolbar - Basic buttons for executing queries.

• Advanced Toolbar - Contains transaction buttons like Start, Commit, Rollback,

Query Building buttons like Select, From, Where, Group By and other operations.

• Object Browser - View databases, tables, views, bookmarks, and history.

• Information Browser - Part of the sidebar to look up syntax, built-in functions,

parameters, etc

• Edit/Navigation Bar - Bottom bar to go into Edit mode and navigate the result set.

Keyboard Shortcuts

A few keyboard shortcuts make using the MySQL Query Browser more

efficient and convenient:

Ctrl+Return executes the current SQL command (like EXECUTE).

Ctrl+Shift+Return executes the command but shows the result in a new

dialog sheet. This has the advantage that the results of previous commands

remain available.

F11 changes the arrangement of the individual windows and enlarges the

input region for SQL commands. This makes it easier to enter long SQL

commands. If you press F11 again, the standard layout is restored.

F12 closes the individual windows except for the current result region. This

makes it easier to read extensive results. Pressing F12 again restores the

original window layout.

SQL Commands with Mouse Clicks

Using various arrow buttons of the Toolbar, you can assemble

SQL commands with minimal typing effort. The following click

sequences provide an example:

• Click on the button SELECT.

• Expand table film to see its columns.

• Click on the columns title, rating, and rental_rate of

the film table.

• Click on the button WHERE.

• Click on the column film_id of the film table.

• Type in =101 (for the WHERE condition) from the

keyboard.

• Click on the button ORDER.

• Click on the column title of the film table.

Note: If you do not see SELECT buttons, click on the menu

option VIEW and select Maximize Query Edit or press F11.

From the mouse clicks (and minimal typing) above, the MySQL Query Browser

forms the following command:

SELECT f.`title`, f.`rating`, f.`rental_rate` FROM film f

WHERE f.`film_id`=101

ORDER BY f.`title`

• f is an alias for the flim table. MySQL Query Browser does not use the

optional AS.

• Execute: Click on the EXECUTE button or hit Ctrl+Enter to run the SQL

statement and see its results.

• Save: Select FILE | SAVE AS from the menu to save the query to a file.

• Exporting results: With FILE | EXPORT RESULTSET you can export the most

recent result of SELECT commands in the formats CSV, HTML, XML, and

Excel.

• View BLOBs: The content of BLOB columns are not displayed by default. You

can view BLOB data in a separate editor window, even dump the blob to a file.

• Explain Query: The button EXPLAIN gives internal, execution-related

information about the planned execution of the most recent SQL command by

MySQL. The meaning of various aspects of the Explain Plan is discussed in

another lesson.

•Updating Data: We can execute UPDATE, INSERT, DELETE, and other

data altering commands.

• Transactions: With InnoDB tables, we can execute transaction-oriented

commands via buttons for START TRANSACTION | COMMIT |

ROLLBACK.

• Refresh: In a multi-session, multi-user situation, the displayed result set

may be refreshed to get the latest matching rows.

• Multiple Result Regions: With FILE | NEW QUERY TAB you open an

additional SQL input field and result region. In this way you can test

several SQL commands in parallel.

History and Bookmarks for SQL Commands

The MySQL Query Browser stores all executed SQL commands

automatically in a History List, available in the sidebar to the right of the

window. With drag and drop you can move the command into the input

region and execute it with a double click.

Using Scripts: Executing Several Commands

Open a SQL script input area with FILE | NEW SCRIPT TAB.

There you can specify several SQL commands separated by

semicolons. You can then execute these commands all at

once (EXECUTE button) or step by step (SCRIPT menu).

These scripts represent several ordinary SQL commands, not

stored procedures. The commands can be stored as

a *.sql file using the FILE menu. The history and bookmark

functions, however, are not available.

MySQL Help - Information Browser

The Information Browser provides access to all information that is not directly

related to actual data within your database.

• The Syntax Browser - A convenient reference to MySQL query

syntax, it is your quick help in finding the correct syntax for building up

the queries.

• The Function Browser - The Function Browser is a quick reference

to the various functions built into MySQL.

• The Parameter Browser - The Parameter Browser provides

different local, global, and dynamic parameters that can help build

your queries.

Local parameters affect the query in the current query window

only.

Global parameters affect all queries.

Dynamic parameters are generated automatically from existing

queries.

• The Transaction Browser - A single transaction could be made up

of many queries. The Transaction Browser lists all queries that make

up a single transaction and serves as a history for a single

transaction.

Object Browser

In the Object Browser, you can view the databases and their various components

in a nested tree-style.

•Database Browser - The Database/schemata Browser is the primary screen of

the Object Browser. You can use the Database Browser to select tables and fields,

edit tables, create new tables and databases, and drop tables and databases. The

Database Browser can be used to set the default database, which is required

before you can issue queries against tables.

•Result Browser - You can place your more commonly used queries in bookmarks

so that you can quickly retrieve them and re-use them later. To add a query to your

bookmarks, highlight and drag it from the query area into the bookmark browser.

Your bookmarks can be organized into folders and subfolders to help with

management of your queries. The Bookmark Browser is one of a number of XML

files use for internal purposes by the Query Browser.

•The History Browser - With the History Browser you can browse through all the

queries you have previously issued. You can create bookmarks from history items

by right-clicking on a selected history item and choosing the Add History Item as

Bookmark menu option.

Changing Data in SELECT Results

With simple SELECT queries containing data from only one table

(no JOINs) and without GROUP BY or aggregation functions, the results

can be changed. To do so, click on the EDIT button at the bottom of the

table. This button is available only for results that can be changed.

To edit the contents of the result area you must enable edit mode through

the use of the Edit button at the bottom of the result area. Any edits you

make are not immediately applied, but instead you need to click the Apply

Changes button next to the Edit button. Clicking the Discard Changes

button throws away any changes you have made to the data.

To change a table field, you must activate it with a double-click. You

simply add new records to the end of the table. To delete a record (a

row), execute DELETE ROWS with the right mouse button. Changes take

effect only after you click the button APPLY CHANGES.

Stored Procedures

The MySQL Query Browser makes available a number of elementary

functions for input of stored procedures, which are functions composed of

several SQL commands that are controlled directly by the MySQL server.

Stored procedures are a characteristic of the MySQL server, while scripts

belong to the MySQL Query Browser. We will discuss stored procedures

in greater detail in a later lesson.

MySQL Administrator

While the MySQL Query Browser helps in assembling and trying out SQL

commands, the MySQL Administrator helps with administrative tasks

related to management of a MySQL server. The various operations one

can perform using the Administrator are covered in a later lesson.

SHOW and DESCRIBE

Statements

Using Table-Related SHOW Statements

We can use the SHOW COLUMNS statement to lists the columns in a table, along

with information about the columns.

Syntax

SHOW [FULL] COLUMNS FROM <table name> [FROM <database

name>] [LIKE '<value>']

FULL keyword shows more complete information about each column, and LIKE

can be used to limit the values returned.

Code Sample:

USE sakilakubili;

SHOW COLUMNS FROM film_review;

SHOW COLUMNS FROM user FROM mysql LIKE 'max%';

You can also retrieve construction information of a table by using a SHOW

CREATE TABLE statement, which shows the actual table definition.

Code Sample:

USE sakilakubili;

SHOW CREATE TABLE film_review;

Note::The entire results may not fit on the screen and what you see depends on

your system.

The next statement displays a list of indexes in a table. The output SHOW INDEX

statement is shown below.

Code Sample:

USE sakila;

SHOW INDEX FROM film_review;

SHOW INDEX FROM user FROM mysql;

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

| Table | Non_unique | Key_name| Seq_in_index| Column_name

Collation | Cardinality | ... | Null | Index_type | Comment |

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

| film_review | 0 | PRIMARY | 1| review_id

A | 0 | ... | | BTREE | |

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

1 row in set (0.00 sec)

The next statement is the SHOW TABLES statement, which

displays a list of tables in the current database or a specified

database.

Code Sample:

USE sakila;

SHOW TABLES;

SHOW TABLES FROM mysql LIKE 'time%';

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

| Tables_in_sakilakubili |

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

| film_review |

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

1 row in set (0.00 sec)

Using DESCRIBE Statement

DESCRIBE is another statement useful for viewing table information. The following

example shows a

DESCRIBE statement that returns information about all columns in the user table

that end with "priv":

DESCRIBE user '%priv';

Code Sample:

SHOW DATABASES;

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

| Database |

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

| information_schema |

| mysql |

| sakila |

| test |

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

4 rows in set (0.11 sec)

Code Sample:

SHOW CREATE DATABASE sakilakubili;

INFORMATION_SCHEMA Tables

INFORMATION_SCHEMA is the information database in MySQL server that

provides access to database metadata, or data about the data, such as a table

name, the constraints on a column, or access privileges. The same informationis

also referred to as data dictionary and system catalog.

Here is an example to list all the tables in sakila database, in reverse alphabetical

order:

Code Sample:

SELECT table_name, table_type, engine

FROM information_schema.tables

WHERE table_schema = 'sakila'

ORDER BY table_name DESC;

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

| table_name | table_type | engine |

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

| actor | BASE TABLE | InnoDB |

| actor_info | VIEW | NULL |

| ... | | ... |

| store | BASE TABLE | InnoDB |

| studio | BASE TABLE | InnoDB |

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

26 rows in set (0.20 sec)

Note:Users prefer to use both SHOW and INFORMATION_SCHEMA

The following example lists the various tables found in INFORMATION_SCHEMA.

Code Sample:

SELECT table_name FROM INFORMATION_SCHEMA.TABLES

WHERE table_schema = 'INFORMATION_SCHEMA'

AND table_name LIKE '%';

Showing Databases

Here is a read of another table which shows that the following statements are

equivalent:

SELECT SCHEMA_NAME AS `Database`

FROM INFORMATION_SCHEMA.SCHEMATA

[WHERE SCHEMA_NAME LIKE '

wild

']

SHOW DATABASES [LIKE '

wild

']

Code Sample:

SELECT SCHEMA_NAME AS `Database`

FROM INFORMATION_SCHEMA.SCHEMATA

WHERE SCHEMA_NAME LIKE 'sakila%';

SHOW DATABASES LIKE 'sakila%';

Identifiers in MySQL

Identifier Names

Like all programming models, MySQL identifiers follow certain

rules and conventions.

Here are the rules to adhere to for naming identifiers to create

objects in MySQL:

• Contain any alphanumeric characters from the default

character set

• Include underscores (_) and dollar signs ($)

• Begin with any acceptable character, including digits

• Cannot be made up entirely of digits

• Cannot include a period (.)

• Cannot include an OS pathname separator, backslash (\)

or forward slash (/)

Schema Object Names

Names for objects within MySQL - database, table, index,

column, alias, view, stored procedure, partition, tablespace -

are known as identifiers. This section describes the allowable

syntax for identifiers in MySQL alongwith which types of

identifiers are case sensitive and under what conditions.

An identifier may be quoted or unquoted. If an identifier

contains special characters or is a reserved word,

you must quote it whenever you refer to it.

A normal name usually comprises the alphanumeric character

set from the current character set, underscore _ and $.

MySQL Reserved words can be found in their documentation.

An exception is when a reserved word that follows a period in

a qualified name must be an identifier, so it need not be

quoted.

Code Sample:

CREATE TABLE create (select1 varchar(10));

CREATE TABLE `create` (`select` varchar(10));

INSERT INTO `create` VALUES('data1');

INSERT INTO `create` VALUES('data2');

SELECT `create`.select FROM `create`;

DROP TABLE `create`;

Code Explanation

creates a table named create that contains a column named select.

The first creation fails, as the names are reserved

words and not quoted.

The second create and the DML statements go through just fine.

As seen in the example, the normal identifier quote character is the backtick `:

mysql> SELECT * FROM `qtest` WHERE `qtest`.`id` = 201;

Using Double Quotes

If the ANSI_QUOTES SQL mode is enabled, it is allowable to quote identifiers

within double quotes. Consequently, when this mode is not-enabled, string literals

must be enclosed within single quotes. They cannot be enclosed within double

quotes.

Code Sample:

DROP TABLE `qtest`;

CREATE TABLE "qtest" (id INT);

SET sql_mode='ANSI_QUOTES';

CREATE TABLE "qtest" (id INT);

SET sql_mode='';

Code Explanation

The first create table statement fails due to use of double-

quotes: ERROR 1064: You have an error in your SQL syntax...

The second create succeeds once ANSI_QUOTES SQL mode is

enabled.

Using Quote Within Names

Quote characters can be included within an identifier if we quote the identifier. If the

character to be included within the identifier is the same as that used to quote the

identifier itself, then we need to repeat that character twice:

Code Sample:

DROP TABLE `c``est`;

CREATE TABLE `c``est` (`la"vie` VARCHAR(10));

INSERT INTO `c``est` VALUES ('one');

INSERT INTO `c``est`(`la"vie`) VALUES ('two');

SELECT `la"vie` FROM `c``est`;

Code Explanation

creates a table named c`est that contains a column named la"vie.

Some basic DML statements are shown as well.

Using Digits

Identifiers may begin with a digit but and may consist solely of digits.

Code Sample:

CREATE TABLE 1234 ( 789 varchar(10));

CREATE TABLE `1234` ( 1id SMALLINT, `789` varchar(10));

INSERT INTO `1234` VALUES(1,'digits1');

INSERT INTO `1234` VALUES(2,'digits2');

SELECT 1id, `789` FROM `1234`;

DROP TABLE `1234`;

Code Explanation

creates a table named 1234 that contains two columns

named 1id and 789.

The first create table statement fails due to missing backtick

for 789: ERROR 1064: You have an error in your SQL syntax...

The 1id column does not need a backtick.

Some basic DML statements are included as well.

Some Restrictions

There are some restrictions on the characters that may appear in identifiers:

Note: Please avoid using 5e or 2e2 as identifiers, because where the names

themselves make up an expression. Depending on context, it might be interpreted

as the expression1e + 3 or as an exponential number 1e+3.

Warning: Avoid using any algorithms such SHA or MD5 to generate table names

because these programs can produce names in illegal or ambiguous formats.

A user variable cannot be used directly in an SQL statement as an identifier or as

part of an identifier.

No identifier can contain ASCII 0 (0x00) or a byte with a value of 255.

Database, table, and column names should not end with space characters.

MySQL has relaxed some restrictions 5.1.6 onwards for database and table

names. Earlier, these objects could contain characters that are not allowed in

filenames, such as /, \, .. As of MySQL 5.1.6, special characters in database and

table names are encoded in the corresponding filesystem names

The following table describes the maximum length for each type of identifier.

Identifier

Max Length (chars)

Database

64

Table

64

Column

64

Index

64

Stored Function or Procedure

64

Trigger

64

View

64

Identifier

Max Length (chars)

Event

64

Tablespace

64

Log File Group

64

Alias

255

Identifiers are stored using Unicode (UTF-8). This applies to identifiers in table

definitions that are stored in .frm files and to identifiers stored in the grant tables

in the mysqldatabase. The allowable Unicode characters are those in the Basic

Multilingual Plane (BMP). Supplementary characters are not allowed.

Identifier Qualifiers

MySQL uses names with a single identifier or a multiple-part name with identifiers

separated by a period ".". The initial parts of a multiple-part name affect the context

to which the final identifier is related.

In MySQL, you can refer to a table column as column_name (read from first table

with the column) or table_name.column_name (read from default database) or

fully-qualifieddb_name.table_name.column_name.

Prefixing db_name or table_name is optional unless the reference to column would

be ambiguous.

Note: When using quotes, quote components individually rather than name as a

group. For example, write `some-table`.`some-column` and not `some-table.some-

column`.Reserved words need not be quoted.

Code Sample:

USE `sakila`;

SELECT `category`.`name` FROM `category`;

USE `mysql`;

SELECT `category`.`name` FROM `sakila`.`category`;

Code Explanation

The components are selected specifying qualified names.

The syntax .tbl_name means the table tbl_name in the default

database (Accepted for ODBC compatibility).

Code Sample:

SELECT * FROM .category;

Code Explanation

The category table has a DOT prefixing it in SELECT.

Creating Databases

To store data in MySQL, we will set up a database and then place tables,

relationships and other objects in that database, following a design that maps to

our application requirements. We will use a command-line tool - mysql, running a

script to generate our objects. Several other options are available to create

components via User Interfaces such as phpMyAdmin, MySQL Query

Browser and MySQL Workbench.

MySQL Query Browser

A product from MySQL that provides a good set of drag-and-drop tools to

visually define, run, manage and optimize SQL queries for MySQL Databases.

Covered in another lesson.

Syntax

<database definition>::=

CREATE DATABASE [IF NOT EXISTS] <database name>

[[DEFAULT] CHARACTER SET <character set name>]

[[DEFAULT] COLLATE <collation name>]

Note: If the database named above already exists, the statement above will throw

an error. By specifying the IF NOT EXISTS clause, MySQL returns just a note

(warning).

The CHARACTER SET specifies the default character set to use and

the COLLATE clause selects default collation for ordering. More on these

later.

We will now set up our new database sakilakubili using mysql.

Code Sample:

CREATE DATABASE sakilakubili;

USE sakilakubili;

The 1 row affected response from mysql indicates that one row was

changed in the internal MySQL table containing the list of all databases. On

statement execution, a database named sakilakubili is added to MySQL

server. The database uses the default character set and collation as we

didn't specify any.

Note:On Windows, all object names, such as databases and tables, are

converted to lowercase. In Linux and other Unix-like operating systems, the

case is preserved. More on case- senstivity in other lessons.

Here, we actually specify the character set and collation to use:

Code Sample:

CREATE DATABASE sakilakubili

DEFAULT CHARACTER SET latin1

DEFAULT COLLATE latin1_bin;

Creating Databases -

Deleting databases

Deleting Databases

A database is dropped via the DROP DATABASE statement.

Syntax

DROP DATABASE [IF EXISTS] <database name>

Code Sample:

DROP DATABASE sakilakubili;

Warning: When a database is dropped, the tables and their data stored in

that database are also deleted. Exercise extreme caution executing

the DROP DATABASE command.

Creating Tables

We will now create additional tables in the sakila database using CREATE TABLE.

First, we must specify the database we will be working with.

The USE database sets the default database to which further commands will be

applied. In other words, the USEcommand selects an active database among

several databases under MySQL management.

Tables provide a structure for storing and securing the data. All data exists within

the structure of the tables, and tables are grouped inside of the database. In

addition to creating tables, you can also modify the table definitions or drop the

tables from the database.

The CREATE TABLE statement includes appropriate column definitions and

constraints to be used for the entity associated with the table. The

fundamental CREATE TABLEstatement is complex and contains various clauses

and options to complete its definition. This lesson focuses on the essential clauses

in a table definition.

The syntax block below shows the basic CREATE TABLE syntax. We will discuss

theses clauses one by one in this lesson.

Syntax

<table definition>::=

CREATE [TEMPORARY] TABLE [IF NOT EXISTS] <table name>(

<table element>

[{, <table element>}...]

)

{ENGINE = {MEMORY | INNODB | MERGE | MYISAM}}

| <additional table options>

Here is an example:

Code Sample:

DROP TABLE IF EXISTS film_review;

CREATE TABLE film_review (

review_id INTEGER,

film_id SMALLINT NOT NULL,

review_text VARCHAR(255) NOT NULL

) ENGINE=InnoDB;

Tip:The CREATE TABLE command can span multiple lines, and each line is

terminated with a Carriage Return.

Dropping Tables

To drop or delete a table, use the DROP TABLE statement.

Syntax

DROP [TEMPORARY] TABLE [IF EXISTS] <table name> [{, <table

name>}...]

Some Tips:

The optional TEMPORARY keyword prevents the inadvertent loss of a permanent

table.

When the IF EXISTS clause is used with a non-existent table, a warning is thrown

instead of an error. Warnings do not stop the execution of a multi-statement script in

its tracks.

We can use the DROP statement to drop several tables.

Code Sample:

DROP TABLE IF EXISTS reservation;

Warning: A master table referenced in a foreign key cannot be dropped without first

removing the reference.

Defining Table Types

One especially important MySQL table options allows us to define the type of table

that you create in your table definition.

Syntax

CREATE TABLE table-name (

... columns ... )

ENGINE = {MYISAM | INNODB | MEMORY | MERGE}

We will create a table called film_info of type ISAM.

Code Sample:

DROP TABLE IF EXISTS film_info;

CREATE TABLE film_info (

film_id SMALLINT NOT NULL,

info_text VARCHAR(10000) NOT NULL

) ENGINE=MyISAM;

Altering Existing Table Structures

Using ALTER TABLE, MySQL allows you to change an existing table in several

ways, such as adding or dropping columns, change existing column definitions,

adding PRIMARY KEY and FOREIGN KEY constraints, or remove constraints.

Altering table requires a good understanding of columns and constraints which are

discussed in subsequent lessons.

Syntax

ALTER TABLE <table name>

<alter option> [{, <alter option>}...]

<alter option>::=

{ADD [COLUMN] <column definition> [FIRST | AFTER <column name>]}

| {ADD [COLUMN] (<table element> [{, <table element>}...])}

| {ADD [CONSTRAINT <constraint name>] PRIMARY KEY

(<column name> [{, <column name>}...])}

| {ADD [CONSTRAINT <constraint name>] FOREIGN KEY [<index name>]

(<column name> [{, <column name>}...]) <reference definition>}

| {ADD [CONSTRAINT <constraint name>] UNIQUE [<index name>]

(<column name> [{, <column name>}...])}

| {ADD INDEX [<index name>] (<column name> [{, <column name>}...])}

| {ADD FULLTEXT [<index name>] (<column name> [{, <column

name>}...])}

Cont..,

| {ALTER [COLUMN] <column name> {SET DEFAULT <value> | DROP

DEFAULT}}

| {MODIFY [COLUMN] <column definition> [FIRST | AFTER <column

name>]}

| {CHANGE [COLUMN] <column name> <column definition> [FIRST |

AFTER <column name>]}

| {DROP [COLUMN] <column name>}

| {DROP PRIMARY KEY}

| {DROP INDEX <index name>}

| {DROP FOREIGN KEY <constraint name>}

| {RENAME [TO] <new table name>}

| {ORDER BY <column name> [{, <column name>}...]}

| CONVERT TO CHARACTER SET charset_name [COLLATE

collation_name]

| [DEFAULT] CHARACTER SET charset_name [COLLATE collation_name]

| {<table option> [<table option>...]}

Each of the alter options relates to a table definition option, and is preceded

with an action keyword - ADD, ALTER, or DROP.

Add a column

A basic use of altering table is to add columns. In this demo, we are adding a

column we forgot to add.

Code Sample:

ALTER TABLE film_review

ADD COLUMN review_date DATETIME;

Renaming Tables

An existing table can be renamed with another name, as shown

Code Sample:

CREATE TEMPORARY TABLE temp_table( column1 SMALLINT );

ALTER TABLE temp_table RENAME temp2_table;

DROP TABLE temp_table; -- Should give an error !

DROP TABLE temp2_table; -- That works !!

Creating Column Definitions

We will create column definitions for each column that needs to be part of the table.

Two core elements required in a column definition are the column name (any

acceptable MySQL identifier) and a supported data type, but several other elements

can be specified with a column as shown in the syntax for table elements below.

Syntax

<table element>::=

<column definition>

| {[CONSTRAINT <constraint name>] PRIMARY KEY

(<column name> [{, <column name>}...])}

| {[CONSTRAINT <constraint name>] FOREIGN KEY [<index name>]

(<column name> [{, <column name>}...]) <reference definition>}

| {[CONSTRAINT <constraint name>] UNIQUE [INDEX] [<index name>]

(<column name> [{, <column name>}...])}

| {{INDEX | KEY} [<index name>] (<column name> [{, <column name>}...])}

| {FULLTEXT [INDEX] [<index name>] (<column name> [{, <column

name>}...])}

<column definition>::=

<column name> <type> [NOT NULL | NULL] [DEFAULT <value>]

[AUTO_INCREMENT]

[PRIMARY KEY] [COMMENT '<string>'] [<reference definition>]

Cont.,

<type>::=

<numeric data type>

| <string data type>

| <data/time data type>

<reference definition>::=

REFERENCES <table name> [(<column name> [{, <column name>}...])]

[ON DELETE {RESTRICT | CASCADE | SET NULL | NO ACTION | SET

DEFAULT }]

[ON UPDATE {RESTRICT | CASCADE | SET NULL | NO ACTION | SET

DEFAULT }]

[MATCH FULL | MATCH PARTIAL]

Data Types in MySQL

Every table is composed of a number of columns. For each

column, an intended data type must be specified. This section

provides an overview of the data types available in MySQL. A

data type is essentially a constraint on a column which defines

and limits the type of values that can be stored in that column.

Numeric Data Types

Numeric data types fall under two key categories: integer or

fractional. UNSIGNED option disallows negative values in the column. There

are several integer types in MySQL to store various range of values as shown:

Data type Acceptable values Storage

TINYINT Signed: -128 to 127 Unsigned: 0 to 255 1

byt

e

SMALLINT Signed: -32768 to 32767 Unsigned: 0 to 65535 2

byt

es

MEDIUMINT Signed: -8388608 to

8388607

Unsigned: 0 to 16777215 3

byt

es

INT/INTEGER Signed: -2147483648 to

2147483647

Unsigned: 0 to 4294967295 4

byt

es

BIGINT Signed: -

9223372036854775808

to

9223372036854775807

Unsigned: 0 to

18446744073709551615

8

byt

es

The fractional data types support the use of data in post decimals places.

Data type Range of Values Storage

FLOAT -3.402823466E+38 to -

1.175494351E-38 0

1.175494351E-38 to

3.402823466E+38

4 bytes

DOUBLE [PRECISION]/REAL 1.7976931348623157E+30

8 to -

2.2250738585072014E-308

0 2.2250738585072014E-

308 to

1.7976931348623157E+30

8

8 bytes

DEC/DECIMAL/NUMERIC/FIXED Range and Storage

requirements depend on the

<length> and <decimals>

values specified in the

column definition

Depends

Relational Database

Concepts

Brief History of SQL

In 1970, Dr. E.F. Codd published "A Relational Model of Data

for Large Shared Data Banks," an article that outlined a model

for storing and manipulating data using tables. Shortly after

Codd's article was published, IBM began working on creating

a relational database. Between 1979 and 1982, Oracle (then

Relational Software, Inc.), Relational Technology, Inc. (later

acquired by Computer Associates), and IBM all put out

commercial relational databases, and by 1986 they all were

using SQL as the data query language.

In 1986, the American National Standards Institute (ANSI)

standardized SQL. This standard was updated in 1989, in

1992 (called SQL2), and again in 1999 (called SQL3).

Standard SQL is sometimes called ANSI SQL or SQL92. All

major relational databases support this standard but each has

its own proprietary extensions. Unless otherwise noted, the

SQL taught in this course is the standard ANSI SQL.

Relational Database Management System

A Relational Database Management System (RDBMS), commonly (but

incorrectly) called a database, is software for creating, manipulating, and

administering a database. For simplicity, we will often refer to RDBMSs as

databases.

Popular Databases

Commercial Databases

Oracle: Oracle is the most popular relational database. It runs on both Unix

and Windows. It used to be many times more expensive than SQL Server

and DB2, but it has come down a lot in price.

SQL Server: SQL Server is Microsoft's database and, not surprisingly, only

runs on Windows. It has only a slightly higher market share than Oracle on

Windows machines. Many people find it easier to use than Oracle.

DB2: IBM's DB2 was one of the earliest players in the database market. It is

still very commonly used on mainframes and runs on both Windows and

Unix.

Popular Open Source Databases

MySQL: Because of its small size, its speediness, and its support with

solid documentation, MySQL has quickly become the most popular

open source database. MySQL is available on several operating

systems, including Windows and Unix.

PostgreSQL: Until recently, PostgreSQL was the most popular open

source database until that spot was taken over by MySQL. PostgreSQL

now calls itself "the world's most advanced Open Source database

software." The latest versions support features like native-language

programming, advanced indexes and a query rewrite systemthat allows

the database designer to create rules to dynamically transform

operations on tables/views into alternate operations upon processing.

A relational database at its simplest is a set of tables used for storing data.

Each table has a unique name and may relate to one or more other tables

in the database through common values.

Tables

A table in a database is a collection of rows and columns. Tables are also known as

entities or relations.

Rows

A row contains data pertaining to a single item or record in a table. Rows are also

known as records or tuples.

Columns

A column contains data representing a specific characteristic of the records in the

table. Columns are also known as fields or attributes.

Relationships

A relationship is a link between two tables (i.e, relations). Relationships make it

possible to find data in one table that pertains to a specific record in another table.

Datatypes

Each of a table's columns has a defined datatype that specifies the type of data that

can exist in that column. For example, the FirstName column might be defined

as varchar(20), indicating that it can contain a string of up to 20 characters.

Unfortunately, datatypes vary widely between databases.

Primary Keys

Most tables have a column or group of columns that can be used to identify records.

For example, an Employees table might have a column called EmployeeID that is

unique for every row. This makes it easy to keep track of a record over time and to

associate a record with records in other tables.

Foreign Keys

Foreign key columns are columns that link to primary key columns in other tables,

thereby creating a relationship. For example, the Customers table might have a

foreign key column called SalesRep that links to EmployeeID, the primary key in

the Employees table.

Valid Object References

server.database.owner.object

server.database..object

server..owner.object

server...object

database.owner.object

database..object

owner.object

object

SQL Statements

Database Manipulation Language (DML)

DML statements are used to work with data in an existing database. The most

common DML statements are:

SELECT

INSERT

REPLACE

UPDATE

DELETE

Database Definition Language (DDL)

DDL statements are used to structure objects in a database. The most common

DDL statements are:

CREATE

ALTER

DROP

Database Control Language (DCL)

DCL statements are used for database administration. The most common DCL

statements are:

GRANT

DENY (SQL Server Only)

REVOKE

Database Design Principles

Modeling and designing a database comes first in any database application. Database

design greatly impacts the development, performance, maintenance and the flexibility

of the application. Bad decisions and errors of the design phase will continue to cause

long-term trouble and ill- effects.

Database design for any non-trivial application is not easy and usually requires

experience. This lesson will present a quick refresher with some pointers to the

fundamentals of relational databases. It summarizes different data types, table types

available under MySQL, and demonstrates normalization rules. In addition, indexes

and integrity rules such as foreign key constraints are also covered.

The database design should be centered around the needs of various users, generally

understood via a detailed requirement analysis of the system. A database designer

must understand the usage patterns of the data. This understanding is reached by

interviewing potential users towards analysis of the organization's database needs.

The database designer must determine items such as:

Data items to be stored

Tasks or Operations to be performed with this data

Frequency of these operations

Restrictions and Constraints on the data

Security of data

Database modeling tools capture the designer's understanding of the database

requirements and the resulting database model leads to a database design.

Basic Modeling Process: Creating a Data Model

A relational model is based on tables and on the meaningful relationships between

those tables. Specifically, a table is made up of columns and rows that form a

table-like structure. The rows are identified through the use of primary keys, and

the columns map to various attributes for an entity.

Using these concepts, we design a database that adheres to the standards of the

relational model.

A data model for a relational database should show all of the following information:

The tables or potential entities that make up the database

The columns that make up each table

The data type that defines each column

The primary key that identifies each row

The relationships that exist between tables

Refine the data model towards full normalization

The Entity-Relationship Model

The popular Entity-Relationship (ER) model is often used for modeling databases.

Its benefits lie in its simplicity, clarity, and simple graphical representation of data

and their relationships. Data is described using concepts such as "entities," "entity

sets," "attributes," and "relationships."

Entities And Entity Sets

An entity is a distinct object distinguishable from other objects. For example, a film

and a customer are two different entities. A collection of similar entities group to

form entity sets.

Attributes

Properties of Entities are called attributes. For example,

• the rating of a film is an attribute of the entity film, and

• the last name and address of a customer are attributes of the entity customer.

Attributes have values associated with them, individually identified with an entity.

For example, a film has a rental rate of $3.99, and is different from another film

with the same rate of $3.99. A customer entity whose attribute last name has the

value Burke is different from another customer with last name as Hagan.

Different attribute values distinguish similar entities in the same entity set from

each other, but many entities can have the same attribute value. For example,

there can be several film entities with the same rental rate.

An entity must have one or more attributes. All entities in an entity set have the

same attributes. A subset of attributes are used to distinguish entities in an entity

set from each other generally called a key of the entity set. Entities in an entity set

must have a unique set of values for the key.

Relationships

A relationship instance specifies an association between entities. For example,

Customers reserve and rent films. The process of Reservations relates a customer

and the films reserved.

Entities can have several types of relationships:

One-To-One: An entity in one entity set is associated with at most one entity in the

other entity set and vice versa.

One-To-Many: An entity in one entity set is associated with many (zero or more)

entities in the other entity set.

Many-To-One: Many (zero or more) entities in one entity set can be associated with

one entity in the other entity set.

Many-To-Many: Many (zero or more) entities in one entity set can be associated

with many entities in the other entity set.

Business rules indicate a relationship between two or more tables. Let us identify

persistent (worth-storing) relationships in our sakila database.

Customers reserve films - Many to many

Customers have rental transactions on film copies - Many to many

A film is of a certain category and in a certain language - Many to one

Different staff reserves and rents films to customers - Many to many

Relationships can also have attributes. They are used to give information about the

relationship. For example, the rental_date attribute in the rent relationship can be

used to describe when a film was rented.

Relationship Types

One of the defining characteristics of a relational database is the

fact that various types of relationships exist between tables. These

relationships allow the data in the tables to be associated with each other

in meaningful ways that help ensure the integrity of normalized data.

Because of these relationships, actions in one table cannot adversely

affect data in another table.

For any relational database, there are three fundamental types of

relationships that can exist between tables: one-to-one relationships, one-

to-many relationships, and many-to-many relationships. This section takes

a look at each of these relationships.

One-to-One Relationships

A one-to-one relationship can exist between any two tables in which a row

in the first table can be related to only one row in the second table and a

row in the second table can be related to only one row in the first table.

Several different systems are used to represent the relationships between

tables, all of which connect the tables with lines that have special

notations at the ends of those lines. The examples in this lesson use a

very basic system to represent the relationships.

Generally, one-to-one relationships are the least likely type of

relationships to be implemented in a relational database; however, there

are sometimes reasons to use them. For example, you might want to

separate tables simply because one table would contain too much data, or

perhaps you would want to separate data into different tables so you could

set up one table with a higher level of security. Even so, most databases

contain relatively few, if any, one-to-one relationships. The most common

type of relationship you're likely to find is the one-to-many.

One-to-Many Relationships

As with one-to-one relationships, a one-to-many relationship can exist

between any two tables in your database. A one-to-many relationship

differs from a one-to-one relationship in that a row in the first table can be

related to one or more rows in the second table, but a row in the second

table can be related to only one row in the first table.

A one-to-many relationship is probably the most common type of

relationship you'll see in your databases. A many-to-one relationship is

simply a reversing of the order in which the tables are referred.

Many-to-Many Relationships

A many-to-many relationship can exist between any two tables in which a

row in the first table can be related to one or more rows in the second

table, but a row in the second table can be related to one or more rows in

the first table. When a many-to-many relationship exists, it is implemented

by adding a third table between these two tables that matches the primary

key values of one table to the primary key values of the second table,

making a many-to-many relationship as logical.

Linking via Foreign Keys

One other aspect to notice in the film table is the language_id column tagged

FK1. FK is an acronym for a Foreign Key. As a foreign key, the language_id

column contains a key values from the associated row in the language_id column

in the language table. The foreign key represents a relationship between the two

tables, designated by a line connecting the two tables.

Graphical Representation of a Model

The ER model allows the database design to be represented graphically:

An entity set is represented by a rectangle.

A relationship is represented by a diamond with lines connecting it to the entity

sets that it relates.

A "many" relationship is indicated by an "N" next to the line.

A "one" relationship is indicated by a "1" next to the line.

An attribute is represented by an oval connected by a solid line to the entity set

rectangle or to the relationship diamond.

As an example, consider the basic ER diagram for a few of sakila entities:

Modeling sakila - Film Rentals Database

Our understanding so far leads us to model the sakila database as consisting of

following entity sets:

Customers, Transactions, Films, and following (named)

relationships, Reservations between Customers and Films,

and Rentals between Customers and Films.

Note: Based on our experience, we interpret the non-specific requirement of storing

name and address of a customer in practice as stored in component form, such as

The first and last names of the customer should be stored separately as should the

various sub-elements of the address.

The attributes listed may not uniquely identify a customer (several customers can

belong the same company, several customers can have the same name, a family

can share an address, and so on). Moreover, it may also be desirable to have a

single identifier to uniquely refer to a customer. Consequently, we will add an "ID"

attribute, which will have a unique value for each customer.

Let us examine the reservation operation

ReservationId (a unique id that identifies each order),

CustomerId,

ReserveDate,

Status,

Each reservation must contain information about the customer and the film

reserved. These attributes cannot be in Customers or in Films.

Here is a more complete ER model for some of the tables in the sakila database:

The key (unique value) attributes in the three entity sets are identified by shaded

ovals.

Note: ER modeling may not lead to a unique solution. Usually, complex

databases are likely to be modeled differently by different database designers.

Physical Model: Mapping The ER Model To A Relational Database

Each entity set in the ER model is represented by a table in a relational

database. Attributes of an entity set becomes the columns of the table.

Primary Key attributes such as film_id, uniquely identify members of the

entity sets.

Each relationship is also represented by a table. A relationship table

includes the key columns of the two entity set tables it relates.

Relationship attributes become columns of the relationship table.

A one-to-many relationship table can be eliminated by storing the

relationship information in one of the tables being related. This is also

possible for many-to-one and one-to-one relationships. For

example, relationships film.language or address.city do not need

attributes, and it would be sufficient to simply put the language_id and

city_id into the film and address entities.

Note: For one-to-many and many-to-one relationships, the mapping

information must be stored in the "many" entity set to avoid creating extra

rows.

Database Normalization

One of the concepts most important to a relational database is that of normalized

data. Normalized data is organized into a structure that preserves the integrity

(consistent with no loss) of the data while minimizing redundant data by keeping

logically related data together.

Once we have identified core entities and their attributes, we will normalize the

data structure and further refine the tables and columns, one entity at a time.

A normalized database contains table structures refined according to the

normalization rules referred to as normal forms - With the introduction of relational

model, Codd included three normal forms. Extended normal forms have been

defined after than, but the first three remain central to a relational model.

There is often a trade-off and therefore a balancing point between strict adherence

to the normal forms and system performance. Often, the more normalized the data,

the more taxing it can be on a system. In most situations, the first three normal

forms sufficiently provide that balance.

As a start, memorize the 3 normal forms so that you can chant them in your sleep:

1NF: No repeating elements or groups of elements

2NF: No partial dependencies on a composite key

3NF: No dependencies on non-key attributes

First Normal Form

For tables in the first normal form (1NF), each column in a

row must be atomic. In other words, the column can contain

only one value for any given row.

Each row in a table must contain the same number of

columns. Given that each column can contain only one value,

this means that each row must contain the same number of

values.

All rows in a table must be different. Although rows might

include the same values, each row, when taken as a whole,

must be unique in the table.

The 1NF property ensures that a data element or column or

attribute of a row is NOT a composite or multi-valued item.

The use of set valued column types can lead to redundancy,

loss of data and inconsistency.

Second Normal Form

Tables in the second normal form (2NF) must be in 1NF and,

All their columns not part of a key must be dependent upon the whole key,

which can be a composite.

Note: A primary key made up of more than one column is referred to as

a composite primary key.

As an example, suppose we have identified that entity film also contains

rental information that differs for various cities where the films are rented.

In other words, we have some data in this entity that is for a film and some

data for the combination of city and film. This table is certainly NOT in 2NF

!

A Non-key column rental_rate, that stores a rate for each film for a given

city is in the film table. This rate does depend on film_id but also depends

on a city_id.

So moving out rental_rate column which depends on the non-key city

column will make the film table be in 2NF (assuming it satisfies the 1NF

requirement). Values of the eliminated rate column, will be fetched for a

combination of a given store/city and a film.

Before the move, the film table is not in 2NF. Note that changing the daily

rate for a film without corresponding changes in column city_id will lead to

data inconsistency.

We will move the rental_rate into a separate rental_city table, which will

have both city_id and film_id part of its composite key. Now database from

this association is in 2NF.

Third Normal From

Tables in the third normal form (3NF) must be in 2NF and,

No non-key column should depend upon another non-key column. In other

words, all non-key columns must depend only upon the entity's key.

All nonprimary key columns in the table must be dependent on the primary

key and must be independent of each other.

A 2NF table can be converted to 3NF by removing the non-key columns

whose values are determined by other non-key columns.

For example, all films are made by a certain studio. If attributes like studio-

size are present in the film table, it is not in 3NF, as the studio-size has no

dependence on the film itself, rather the non-key studio which made the

film. Moving studio-size into the studio entity will bring film closer to 3NF.

Note: Specifying column B as being dependent (functionally dependent to

be precise) upon column A is equivalent to saying that the values in

column A determine the corresponding values in column B.

MySQL Triggers

Database triggers or triggers are SQL statements

storing in the database catalog. Once a trigger is

activated by database events such as UPDATE,

DELETE or INSERT, it will execute either before or

after the event that initiated it.

Advantages of using SQL trigger

SQL Trigger provides an alternative way to

check integrity.

SQL trigger can catch the errors in business

logic in the database level.

SQL trigger provides an alternative way to run

scheduled tasks. With SQL trigger, you don’t have

to wait to run the scheduled tasks. You can handle

those tasks before or after changes being made to

database tables.

SQL trigger is very useful when you use it to

audit the changes of data in a database table.

Disadvantages of using SQL trigger

SQL trigger only can provide extended validation and

cannot replace all the validations. Some simple validations

can be done in the application level. For example, you can

validate input check in the client side by using javascript

or in the server side by server script using PHP or

ASP.NET.

SQL Triggers executes invisibly from client-application

which connects to the database server so it is difficult to

figure out what happen underlying database layer.

SQL Triggers run every updates made to the table

therefore it adds workload to the database and cause

system runs slower.

Triggers or stored procedures? It depends on the the

situation but it is practical that if you have no way to get

the work done with stored procedure, think about triggers.

Trigger Implementation in MySQL

MySQL finally supports one of the most important features of an enterprise

database server which is called trigger since version 5.0.2. Trigger is

implemented in MySQL by following the syntax of standard SQL:2003. When you

create a trigger in MySQL, its definition stores in the file with extension .TRG in a

database folder with specific name as follows:

/data_folder/database_name/table_name.trg The file is in plain text format so you

can use any plain text editor to modify it.

While trigger is implemented in MySQL has all features in standard SQL but

there are some restrictions you should be aware of like following:

It is not allowed to call a stored procedure in a trigger.

It is not allowed to create a trigger for views or temporary table.

It is not allowed to use transaction in a trigger.

Return statement is disallowed in a trigger.

Creating a trigger for a database table causes the query cache invalidated.

Query cache allows you to store the result of query and corresponding select

statement. In the next time, when the same select statement comes to the

database server, the database server will use the result which stored in the

memory instead of parsing and executing the query again.

All trigger for a database table must have unique name. It is allowed that

triggers for different tables having the same name but it is recommended that

trigger should have unique name in a specific database. To create the trigger,

you can use the following naming convention: (BEFORE |

AFTER)_tableName_(INSERT| UPDATE | DELETE)

CREATE TRIGGER statement is used to create triggers.

The trigger name should follow the naming convention [trigger

time]_[table name]_[trigger event], for example

before_employees_update

Trigger activation time can be BEFORE or AFTER. You must specify

the activation time when you define a trigger. You use BEFORE when

you want to process action prior to the change being made in the table

and AFTER if you need to process action after changes are made.

Trigger event can be INSERT, UPDATE and DELETE. These events

cause trigger to fire and process logic inside trigger body. A trigger only

can fire with one event. To define trigger which are fired by multiple

events, you have to define multiple triggers, one for each event. Be

noted that any SQL statements make update data in database table will

cause trigger to fire. For example, LOAD DATA statement insert records

into a table will also cause the trigger associated with that table to fire.

A trigger must be associated with a specific table. Without a table

trigger does not exist so you have to specify the table name after the ON

keyword.

You can write the logic between BEGIN and END block of the trigger.

MySQL gives you OLD and NEW keyword to help you write trigger

more efficient. The OLD keyword refers to the existing row before you

update data and the NEW keyword refers to the new row after you

update data.

In this tutorial, you have learned how to create the first trigger in MySQL.

You've written the first trigger to audit changes of last name of employee

in employees table.

Managing Trigger in MySQL

Summary: In this tutorial, you will learn how to

manage triggers in MySQL including listing all

triggers in a given database or removing triggers.

Once created trigger associated with a table, you

can view the trigger by going directly to the folder

which contains the trigger. Trigger is stored as plain

text file in the database folder as follows:

/data_folder/database_name/table_name.trg, with

any plain text editor such as notepad you can view

it. MySQL provides you another way to view the

trigger by executing SQL statement:

1 SELECT * FROM Information_Schema.Trigger

2 WHERE Trigger_schema = 'database_name' AND

MySQL Views

A database view is known as a "virtual table"

which allows you to query the data against it.

Understanding database view and using it

correctly are very important. In this section, you

will learn how database view is, how it

implemented in MySQL and how to use it

effectively

Introduction to Database

View

By definition, a database view or view is a virtual or logical

table which is composed of result set of a SELECT query.

Because the database view is similar to the database table

which consists of row and column so you can retrieve and

update data on it in the same way with table. The database

view is dynamic because it is not related to the physical

schema. Database view is stored as view definition as

SELECT statements. When the tables which are the source

data of a view changes; the data in the view change also.

Views Advantages

Database views provide several advantages as follows:

Simplify complex query. A view is defined by an SQL statement with

join on many underlying tables with complex business logic. The view

now can be used to hides the complexity of underlying tables to the end

users and external applications. Only simple SQL statement is used to

work with view.

Limited access data to the specific users. You may don’t want a subset

of sensitive data can be retrievable by all users (both human and

applications). You can use view to expose what data to which user to

limit the access.

Provide extra security. Security is vital parts of any relational database

management system.Views provide extra security the database

management system. View allows you to create only read-only view to

expose read-only data to specific user. User can only retrieve data in

read-only view but cannot update it.

Computed column. The database table should not have the calculated

columns in it so you can use views to create computed columns.

Suppose in the orderDetails table you havequantityOrder (number of

ordered product) and priceEach (price per product item) columns but it

does not have computed column to get the total cost for each line of

order. In this case, you can create computed column call total which is

equal to quantityOrder multiple withpriceEach to storedthe computed

result.

Backward compatibility. You have a center database and

all applications use that database as their sources of data.

One day you redesign the database to make it more clean

and normalized. You then move the entire legacy data into

the new database but you don’t want affect the legacy

application in accessing it. In this case, you can use views

to make them like the legacy database schema and return

the same data so the legacy application won’t be affected.

MySQL Views

MySQL supports views from version 5.x and almost views’

features conform to the SQL: 2003 standard. Queries of

views in MySQL are processed in two ways:

MySQL creates a temporary table based on the query which

defined the view and then execute the input query on this table.

MySQL first combines the input query and query which

defined the view, then MySQL executes this query.

MySQL supports versioning system for views. Each time when

the view is altered or replaced, a copy of the existing view is

back up in arc (archive) folder which is resided in specific

database folder. The name of back up file is view_name.frm-

00001. If you later change the view again, it will be named as

view_name.frm-00002.

MySQL also allows you to create views of views. In the

SELECT statement of view definition, you can reference to

another views.

If the cached is enabled, the query against view is stored in the

cache. As the result, it increases the performance of query by

pulling data from the buffering instead of querying data from

physical hard disk.

Algorithms

The algorithm attribute allows you to control which mechanism is

used when creating a view.

MERGE means the input query will combine with the SELECT

statement in the view definition and MySQL will execute the

combined query to return the result set. This mechanism is more

efficient than using TEMPTABLE (temporary table) but MERGE

only allowed when the rows in the view represent a one-to-one

relationship with the rows in the underlying table. In case the

MERGE is not allowed, MySQL will switch the algorithm to

UNDEFINED. The combination of input query and query in view

definition into one query sometimes refers as view resolution.

TEMPTABLE means MySQL first create a temporary table

based on SELECT statements in the view definition, and then it

executes the input query against this temporary table. Because

MySQL has to create temporary table to store the result set so it

has to move the data from the real database table to the

temporary table therefore TEMPTABLE mechanism is less

efficient than MERGE. In addition, views which use TEMPTABLE

algorithm is not updateable.

View name

Each view is associated with a specific database therefore

you can have database name prefix with the view name.

View name is shared the same domain with tables so it

cannot be the same name with existing tables or other views

within a database.

SELECT statement

In SELECT statement, you can query any tables or views

existed in the database. There are several rules which

SELECT statement has to follows:

Subquery cannot be included in the SELECT statement.

Any variables such as local, user and session variables

cannot be used in the SELECT statement.

The prepared statement cannot be used in the view.

Temporary tables or views cannot be used in the SELECT

statements and any tables or views which referred by views

must exists.

View cannot be associated with triggers.

Creating Updateable Views

Views are not only read-only but also updateable. However in

order to create an updateable view, the SELECT statement

which defines View has to follow several following rules:

SELECT statement must not reference to more than one

table. It means it must not contain more than one table in

FROM clause, other tables in JOIN statement, or UNION with

other tables.

SELECT statement must not use GROUP BY or HAVING

clause.

SELECT statement must not use DISTINCT in the selection

list.

SELECT statement must not reference to the view that is not

updateable

SELECT statement must not contain any expression

(aggregates, functions, computed columns…)

When you want to create updateable views, check all rules

above or you can remember that data rows in the view must be

one to one relationship with data rows in the underlying tables.

Let’s practice with an example of creating an updateable view.

Sample codes using Query

browser

Sample code:

create database db_mysql;

use db_mysql;

show databases;

Sample codes:

create database db_mysql;

use db_mysql;

CREATE TABLE Persons

(

P_Id int,

LastName varchar(255),

FirstName varchar(255),

Address varchar(255),

City varchar(255));

show databases;

show tables;

create database db_mysql;

use db_mysql;

CREATE TABLE Persons

(

P_Id int,

LastName varchar(255),

FirstName varchar(255),

Address varchar(255),

City varchar(255));

show databases;

show tables;

select * from Persons;

create database db_mysql;

use db_mysql;

CREATE TABLE Persons

(

P_Id int,

LastName varchar(255),

FirstName varchar(255),

Address varchar(255),

City varchar(255));

show databases;

show tables;

select * from Persons;

insert into Persons values('1','Bautista','Guia Lynn','San Pedro

Sto.Tomas','Batangas City');

insert into Persons values('2','Reazo','Rachel','San Joaquin

Sto.Tomas','Batangas city');

The actual view of the sample

code