MySQL Development.docx

8/21/2019 MySQL Development.docx

1/23

1.Basic MySQL Tutorial

A.Manage Database in MySQL

Including - creating a new database, Removing an Existing database, Selecting a database to work withand listing all databases.

Creating DatabaseBefore doing anything else with the data, you need to create a database. In MySQL, a database is acollection of objects that are used to store and manipulate data such as tables, databaseviews,triggers,stored procedures,etc.

CREATE DATABASE [IF NOT EXISTS] database name;

Displaying Databases

SHOW DATABASES;

Selecting a database to work with

Before working with a particular database, you must tell MySQL which database you want to work with

by using the USE statement.

USE database_name;

From now all operations such asquerying data,create new tables orstored procedures which youperform, will take effects on the current database

Removing Databases

Removing database means you delete the database physically. All the data and related objects inside the

database are permanently deleted and this cannot be undone, therefore it is very important to execute

this query with extra cautions.

To delete a database, you use the DROP DATABASE statement as follows:

DROP DATABASE [IF EXISTS] database_name;

Followed the DROP DATABASE is the database name that you want to remove. Similar to the CREATE

DATABASE statement, the IF EXISTS is an optional part of the statement to prevent you from removing a

database that does not exist in the database server.

If you want to practice with the DROP DATABASE statement, you can create a new database, make sure

that it is created and remove it. Take a look at the following queries:

1

2

3

CREATE DATABASE IF NOT EXISTS temp_database;

SHOW DATABASES;

DROP DATABASE IF EXISTS temp_database;
http://www.mysqltutorial.org/basic-mysql-tutorial.aspxhttp://www.mysqltutorial.org/mysql-create-drop-database.aspxhttp://www.mysqltutorial.org/mysql-create-drop-database.aspxhttp://www.mysqltutorial.org/mysql-views-tutorial.aspxhttp://www.mysqltutorial.org/mysql-views-tutorial.aspxhttp://www.mysqltutorial.org/mysql-triggers.aspxhttp://www.mysqltutorial.org/mysql-stored-procedure-tutorial.aspxhttp://www.mysqltutorial.org/mysql-select-statement-query-data.aspxhttp://www.mysqltutorial.org/mysql-create-table/http://www.mysqltutorial.org/mysql-stored-procedure-tutorial.aspxhttp://www.mysqltutorial.org/mysql-stored-procedure-tutorial.aspxhttp://www.mysqltutorial.org/mysql-create-table/http://www.mysqltutorial.org/mysql-select-statement-query-data.aspxhttp://www.mysqltutorial.org/mysql-stored-procedure-tutorial.aspxhttp://www.mysqltutorial.org/mysql-triggers.aspxhttp://www.mysqltutorial.org/mysql-views-tutorial.aspxhttp://www.mysqltutorial.org/mysql-views-tutorial.aspxhttp://www.mysqltutorial.org/mysql-create-drop-database.aspxhttp://www.mysqltutorial.org/basic-mysql-tutorial.aspx


2/23

B. Understanding MySQL Table Types, or Storage Engines

Summary: in this tutorial, you will learn various MySQL table types, or storage engines. It is essential tounderstand the features of each table type in MySQL so that you can use them effectively to maximizethe performance of your databases.

MySQL provides various storage engines for its tables as below:

MyISAM

InnoDB

MERGE

MEMORY (HEAP)

ARCHIVE

CSV

FEDERATED

MySQL supports several storage engines that act as handlers for different table types. MySQL storageengines include both those that handle transaction-safe tables and those that handle nontransaction-safe tables.

Note

Prior to MySQL 5.1.38, the pluggable storage engine architecture is supported on Unix platforms only

and pluggable storage engines are not supported on Windows.

To determine which storage engines your server supports by using theSHOW ENGINESstatement.

The value in the Supportcolumn indicates whether an engine can be used. A value of YES,NO,

or DEFAULTindicates that an engine is available, not available, or available and currently set as the

default storage engine.

mysql> SHOW ENGINES\G

*************************** 1. Row ***************************

Engine: FEDERATED

Support: NO

Comment: Federated MySQL storage engine

Transactions: NULL

XA: NULL

Savepoints: NULL

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

Engine: MRG_MYISAM

Support: YES

Comment: Collection of identical MyISAM tables

Transactions: NO

XA: NO

Savepoints: NO
http://www.mysqltutorial.org/understand-mysql-table-types-innodb-myisam.aspxhttp://www.mysqltutorial.org/understand-mysql-table-types-innodb-myisam.aspxhttp://dev.mysql.com/doc/refman/5.1/en/show-engines.htmlhttp://dev.mysql.com/doc/refman/5.1/en/show-engines.htmlhttp://dev.mysql.com/doc/refman/5.1/en/show-engines.htmlhttp://dev.mysql.com/doc/refman/5.1/en/show-engines.htmlhttp://www.mysqltutorial.org/understand-mysql-table-types-innodb-myisam.aspx


3/23

*************************** 3. Row ***************************

Engine: MyISAM

Support: DEFAULT

Comment: Default engine as of MySQL 3.23 with great performance

Transactions: NO

XA: NO

Savepoints: NO

Each storage engine has its own advantages and disadvantages. It is crucial to understand each storage

engine features and choose the most appropriate one for your tables to maximize the performance of

Change engine for tableAlter table information_schema`. CHARACTER_SETS` engine = MyISAM


4/23

Constraints

Primary Key-The PRIMARY KEY constraint uniquely identifies each record in a database table.

Primary keys must contain unique values.

A primary key column cannot contain NULL values.

Each table should have a primary key, and each table can have only ONE primary key.Foreign Key-Relation Between two tables-establish a link between the data in two tables.

NOT NULL- Indicates that a column cannot store NULL value

UNIQUE- Ensures that each row for a column must have a unique value

CHECK- Ensures that the value in a column meets a specific condition

DEFAULT- Specifies a default value when specified none for this column

Zerofill-When you select a column with type ZEROFILL it pads the displayed value of the field with zeros up to

the display width specified in the column definition. Values longer than the display width are not truncated. Note

that usage of ZEROFILL also implies UNSIGNED.

Using ZEROFILL and a display width has no effect on how the data is stored. It affects only how it is displayed.

Here is some example SQL that demonstrates the use of ZEROFILL:

CREATE TABLE yourtable (x INT(8) ZEROFILL NOT NULL, y INT(8) NOT NULL);

INSERT INTO yourtable (x,y) VALUES

(1, 1),

(12, 12),

(123, 123),

(123456789, 123456789);

SELECT x, y FROM yourtable;

Result:

x y

00000001 1

00000012 12

00000123 123

123456789 123456789

Unsigned-All integer types can have an optional (nonstandard) attribute UNSIGNED. Unsigned type can be used to permitonly nonnegative numbers in a columnor when you need a larger upper numeric rangefor the column. Forexample, if an INT column is UNSIGNED, the size of the column's range is the same but its endpoints shift from -2147483648 and 2147483647 up to 0 and 4294967295.

CREATE TABLE èmployees55` (

Èmp_No` INT(11) UNSIGNED ZEROFILL NOT NULL AUTO_INCREMENT,`Birth_Date` DATE DEFAULT NULL,

`First_Name` VARCHAR(14) NOT NULL,

`Last_Name` VARCHAR(16) NOT NULL,

`Gender` ENUM('M','F') NOT NULL,

`Hire_Date DATE DEFAULT NULL,

PRIMARY KEY (Èmp_No`))

CREATE TABLE dept_emp(

emp_no INT NOT NULL,

dept_no CHAR(4) NOT NULL,

from_date DATE NOT NULL,

to_date DATE NOT NULL,KEY (emp_no), -- Build INDEX on this non-unique-value column


5/23

KEY (dept_no), -- Build INDEX on this non-unique-value column

FOREIGN KEY (emp_no) REFERENCES employees (emp_no) ON DELETE CASCADE,

-- Cascade DELETE from parent table 'employee' to this child table

-- If an emp_no is deleted from parent 'employee', all records

-- involving this emp_no in this child table are also deleted

-- ON UPDATE CASCADE??

FOREIGN KEY (dept_no) REFERENCES departments (dept_no) ON DELETE CASCADE,

-- ON UPDATE CASCADE??

PRIMARY KEY (emp_no, dept_no)

-- Might not be unqiue?? Need to include from_date

);

CREATE TABLE `indextable` (

`card_id` int(10) unsigned zerofill NOT NULL,`card_name` varchar(20) NOT NULL,

PRIMARY KEY (`card_name`),

UNIQUE KEY card_id` (`card_id`)

)

C.MySQL Data Types


6/23

CREATE TABLE test` (`sl_no` TINYINT(3) NOT NULL AUTO_INCREMENT,`emp_id` SMALLINT(6) DEFAULT NULL,`job_id` MEDIUMINT(9) DEFAULT NULL,`mobile_no1` VARCHAR(20) DEFAULT NULL,`mobile_no2` VARCHAR(40) DEFAULT NULL,`ctc_salary` DECIMAL(10,0) DEFAULT NULL,`gross_salary` FLOAT DEFAULT NULL,`net_salart` DOUBLE DEFAULT NULL,`PF` BIT(1) DEFAULT NULL,`name` CHAR(50) DEFAULT NULL,`fname` VARCHAR(50) DEFAULT NULL,`code1` BINARY(50) DEFAULT NULL,`code2` VARBINARY(50) DEFAULT NULL,


7/23

`photo1` TINYBLOB,`photo2` TINYBLOB,`photo3` MEDIUMBLOB,`photo4` LONGBLOB,`remarks1` TEXT,`remarks12` TINYTEXT,`remarks13` MEDIUMTEXT,`remarks14` LONGTEXT,`joining_date1` DATE NOT NULL,`joining_date2` TIME NOT NULL,`joining_date3` DATETIME NOT NULL,`joining_date4` NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,`joining_date5` YEAR(4) NOT NULL,KEY sl_no` (`sl_no`)

)

E. MySQL Sequence

Each table has only one AUTO_INCREMENT column whose data type is typically integer or floatwhich is very rare.

The AUTO_INCREMENT column must be indexed, which means it can be either PRIMARYKEY or UNIQUE index.

The AUTO_INCREMENT column must have NOT NULL constraint. When yousetAUTO_INCREMENT attribute to a column, MySQL will make it NOT NULL for you in case youdont define it explicitly.

CREATE TABLE employees(

emp_no INT(4) AUTO_INCREMENT PRIMARY KEY,

first_name VARCHAR(50),

last_name VARCHAR(50)

)ENGINE = INNODB;

First, insert two new employees into the employees table:

INSERT INTO employees(first_name,last_name)

VALUES('John','Doe'),

('Mary','Jane');

1 SELECT * FROM employees;

Third, delete the second employee whose emp_no is 2:

DELETE FROM employees

WHERE emp_no = 2;
http://www.mysqltutorial.org/mysql-sequence/http://www.mysqltutorial.org/mysql-sequence/http://www.mysqltutorial.org/mysql-sequence/


8/23

Fourth, insert a new employee:


VALUES('Jack','Lee');

Because the storage engine of the employees table is InnoDB, it does not reuse the deleted sequencenumber. The new row has emp_no 3.

Fifth, update an existing employee with emp_no 3 to 1:

UPDATE employees

SET first_name = 'Joe',

emp_no = 1

WHERE emp_no = 3;

MySQL issued an error of duplicate entry for the primary key. Lets fix it:

UPDATE employees

SET first_name = 'Joe',

emp_no = 10

WHERE emp_no = 3;

Sixth, insert a new employee after updating the sequence number to 10:


VALUES('Wang','Lee');

The next sequence number of the last insert is 4, therefore MySQL use 4 for the new row instead of 11.

In this tutorial, you have learned how to use MySQL sequence to generate unique numbers for a primary

key column by assigning the column AUTO_INCREMENT attribute.


9/23

H. Changing Table Structure Using MySQL ALTER TABLE

The ALTER TABLE statement is used to change the structure of existing tables. You can use the ALTERTABLE statement to add or drop column, changedata typeof column, add primary key, rename table andmany more. The following illustrates the ALTER TABLE statement syntax:

ALTER TABLE test ADD PRIMARY KEY(sl_no);ALTER TABLE test DROP PRIMARY KEY,ADD PRIMARY KEY(emp_id);ALTER TABLE test ADD CONSTRAINT CK_Per_Place_Thing_Unique UNIQUE (sl_no);ALTER TABLE test ADD COLUMN complete1 DECIMAL(2,1) NULL;

ALTER TABLE table_name action1[,action2,]

To alter an existing table:

First, you specify the table name that you want to change after the ALTER TABLE keywords.

Second, you list a set of actions that you want to apply to the table. An action can be anything

such as adding a new column, adding primary key, renaming table, etc. The ALTER TABLE statement

allows you to apply multiple actions in a single ALTER TABLE statement, each action is separated by a

comma (,).

Were going to create anew table named tasksin oursample database.The following is the script forcreating the tasks table.

CREATE TABLE tasks (

task_id INT NOT NULL ,

subject VARCHAR(45) NULL ,

start_date DATE NULL ,

end_date DATET NULL ,description VARCHAR(200) NULL ,

PRIMARY KEY (task_id) ,

UNIQUE INDEX task_id_UNIQUE (task_id ASC) );

Changing columns using MySQL ALTER TABLE statement

Using MySQL ALTER TABLE statement to set auto-increment attribute for a column
http://www.mysqltutorial.org/mysql-alter-table.aspxhttp://www.mysqltutorial.org/mysql-alter-table.aspxhttp://www.mysqltutorial.org/mysql-data-types.aspxhttp://www.mysqltutorial.org/mysql-data-types.aspxhttp://www.mysqltutorial.org/mysql-data-types.aspxhttp://www.mysqltutorial.org/mysql-sample-database.aspxhttp://www.mysqltutorial.org/mysql-sample-database.aspxhttp://www.mysqltutorial.org/mysql-sample-database.aspxhttp://www.mysqltutorial.org/mysql-sample-database.aspxhttp://www.mysqltutorial.org/mysql-data-types.aspxhttp://www.mysqltutorial.org/mysql-alter-table.aspx


10/23

Suppose you want thevalue of thetask_idcolumn to be increased automatically by one wheneveryouinsert a new recordinto the tasks table. To do this, you use the ALTER TABLE statement to set the

attribute of the task_id column to AUTO_INCREMENT as follows:

ALTER TABLE tasks

CHANGE COLUMN task_id task_id INT (11) NOT NULL AUTO_INCREMENT;

You can verify the change by adding some records to the tasks table.

INSERT INTO tasks(subject,

start_date,

end_date,

description)

VALUES('Learn MySQL ALTER TABLE',

Now(),

Now(),

'Practicing MySQL ALTER TABLE statement');

INSERT INTO tasks(subject,

start_date,

end_date,

description)

VALUES('Learn MySQL CREATE TABLE',

Now(),

Now(),

'Practicing MySQL CREATE TABLE statement');

And you can query data to see if the value of the task_id column is increased by 1 each time you insert

a new record:

SELECT task_id, description

FROM tasks

Using MySQL ALTER TABLE statement to add a new column into a table

Because of the new business requirement, you need to add a new column called complete to store the

percentage of completion for each task in the tasks table. In this case, you can use the ALTER TABLE to

add a new column to the tasks table as follows:

ALTER TABLE tasks

ADD COLUMN complete DECIMAL(2,1) NULL

AFTER description;

Using MySQL ALTER TABLE to drop a column from a table
http://www.mysqltutorial.org/mysql-insert-statement.aspxhttp://www.mysqltutorial.org/mysql-insert-statement.aspxhttp://www.mysqltutorial.org/mysql-insert-statement.aspxhttp://www.mysqltutorial.org/mysql-insert-statement.aspx


11/23

Suppose you dont want to store the description of tasks in the tasks table and you have to remove it.

The following statement allows you to remove the descriptioncolumn of the tasks table:ALTER TABLE tasks

DROP COLUMN description;

Renaming table using MySQL ALTER TABLE statement

You can use the ALTER TABLE statement to rename a table. Notice that before renaming a table, you

should take a serious consideration to see if the change affects both database and application layers.

The following statement rename the tasks table to work_items:

ALTER TABLE tasks

RENAME TO work_items;

In this tutorial, youve learned how to use the MySQL ALTER TABLE statement to change existing tablestructure and to rename the table.

I. MySQL DROP TABLE statement syntax

In order to remove existing tables, you use the MySQL DROP TABLE statement. The syntax of the DROPTABLE is as follows:

DROP [TEMPORARY] TABLE [IF EXISTS] table_name [, table_name] ...

[RESTRICT | CASCADE]

The DROP TABLE statement removes a table and its data permanently from the database. In MySQL, you can

also remove multiple tables using a single DROP TABLE statement, each table is separated by a comma (,).The

TEMPORARY flag allows you to remove temporary tables only. It is very convenient to ensure that you do not

accidentally remove non-temporary tables.The IF EXISTS addition allows you to hide the error message in case

one or more tables in the list do not exist. When you use IF EXISTS addition, MySQL generates a NOTE, which

can be retrieved by using the SHOW WARNING statement. It is important to notice that the DROP TABLE

statement removes all existing tables and issues an error message or a NOTE when you have a non-existent

table in the list.As mentioned above, the DROP TABLE statement only removes table and its data. However, it

does not remove specific user privileges associated with the table. Therefore if a table with the same name is re-

created after that, the existing privileges will apply to the new table, which may pose a security risk.TheRESTRICT and CASCADE flags are reserved for the future versions of MySQL.Last but not least, you must have

DROP privileges for the table that you want to remove.

MySQL DROP TABLE exampleWe are going to remove the tasks table that we created in the previous tutorial on creating tables usingCREATE TABLE statement. In addition, we also remove a non-existent table to practice with the SHOWWARNING statement. The statement to remove the tasks table and a non-existent table is as follows:DROP TABLE IF EXISTS tasks, nonexistent_table;

If you check the database, you will see that the tasks table was removed. You can check the NOTE, whichis generated by MySQL because of non-existent table, by using the SHOW WARNING statement asfollows:

SHOW WARNINGS;


12/23

MySQL DROP TABLE LIKE

Image you have a lot of tables whose names start with test in your database and you want to save timeby removing all of them using a single DROP TABLE statement. Unfortunately, MySQL does not providethe DROP TABLE LIKE statement that can remove tables based on pattern matching like the following:However, there are some workarounds. We will discuss one of them here for your reference.Lets start creating test* tables for the sake of demonstration.

CREATE TABLE IF NOT EXISTS test1(id int(11) NOT NULL AUTO_INCREMENT,PRIMARY KEY(id)

);

CREATE TABLE IF NOT EXISTS test2 LIKE test1;CREATE TABLE IF NOT EXISTS test3 LIKE test1;

CREATE TABLE IF NOT EXISTS test4 LIKE test1;

Weve created four tables named test1, test2, test3 and test4 with the same table structure.

Suppose you want to remove all test* tables at a time, you can follow the steps below:

First, you declare two variables that accept database schema and a pattern that you want to the tables to

match:

-- set table schema and pattern matching for tables

SET @schema = 'classicmodels';

SET @pattern = 'test%';

Next, you need to build a dynamic DROP TABLE statement:

-- build dynamic sql (DROP TABLE tbl1, tbl2...;)SELECT CONCAT('DROP TABLE ',GROUP_CONCAT(CONCAT(@schema,'.',table_name)),';')INTO @droplikeFROM information_schema.tablesWHERE @schema = database()AND table_name LIKE @pattern;

Basically, the query instructs MySQL to go to the information_schema table , which contains data on alltables in all databases, and to concatenate all tables in the database @schema (classicmodels ) thatmatches the pattern @pattern ( test%) with the prefix DROP TABLE. TheGROUP_CONCAT functioncreates a comma-separated list of tables.Then, we can display the dynamic SQL to verify if it works correctly:

-- display the dynamic sql statementSELECT @droplike;

you can see that it works as expected.

After that, you can execute the statement usingprepared statement in MySQLas follows:
http://www.mysqltutorial.org/mysql-prepared-statement.aspxhttp://www.mysqltutorial.org/mysql-prepared-statement.aspxhttp://www.mysqltutorial.org/mysql-prepared-statement.aspxhttp://www.mysqltutorial.org/mysql-prepared-statement.aspx


13/23

-- execute dynamic sqlPREPARE stmt FROM @dropcmd;EXECUTE stmt;DEALLOCATE PREPARE stmt;

For more information on MySQL prepared statement, check it out theMySQL prepared statementtutorial.

Putting it all together.

-- set table schema and pattern matching for tablesSET @schema = 'classicmodels';SET @pattern = 'test%';

-- build dynamic sql (DROP TABLE tbl1, tbl2...;)SELECT CONCAT('DROP TABLE ',GROUP_CONCAT(CONCAT(@schema,'.',table_name)),';')INTO @droplikeFROM information_schema.tables

WHERE @schema = database()AND table_name LIKE @pattern;

-- display the dynamic sql statementSELECT @droplike;

-- execute dynamic sqlPREPARE stmt FROM @dropcmd;EXECUTE stmt;DEALLOCATE PREPARE stmt;

So if you want to drop multiple tables that have a specific pattern in a database, you just use the scriptabove to save time. All you need to do is replacing the pattern and the database schema in @patternand@schema variables. If you often have to deal with this task, you can always develop a stored procedure

based on the script and reuse the stored procedure in the future.In this tutorial, weve shown you how to use the DROP TABLE statement to remove existing tables in aparticular database. We also discussed about a workaround that allows you to use the DROP TABLEstatement to remove tables based on pattern matching.

J. MySQL Temporary Table

Summary: in this tutorial, we will discuss about MySQL temporary table and show you how to create, useand drop temporary tables.Introduction to MySQL temporary tableIn MySQL, a temporary table is a special type of table that allows you to store a temporary result set,which you can reuse several times in a single session. A temporary table is very handy when it is

impossible or expensive to query data that requires a single SELECT statement with JOIN clauses. Youoften use temporary tables in stored procedures to store immediate result sets for the subsequent uses.MySQL temporary tables have some additional features: A temporary table is created by using CREATE TEMPORARY TABLE statement. Notice thattheTEMPORARY keyword is added between CREATE and TABLE keywords. MySQL drops the temporary table automatically when the session ends or connection isterminated. Of course, you can use the DROP TABLE statement to drop a temporary table explicitly whenyou are no longer use it. A temporary table is only available and accessible by the client who creates the table. Different clients can create a temporary table with the same name without causing errorsbecause only the client who creates a temporary table can see it. However, in the same session, twotemporary tables cannot have the same name. A temporary table can have the same name as an existing table in a database. For example, ifyou create a temporary table named employees in the sample database, the existing employeestable

becomes inaccessible. Every query you issue against the employees table refers to theemployeestemporary table. When you remove the employees temporary table, the permanentemployees table isavailable and accessible again. Though this is allowed however it is not recommended to create a
http://www.mysqltutorial.org/mysql-prepared-statement.aspxhttp://www.mysqltutorial.org/mysql-prepared-statement.aspxhttp://www.mysqltutorial.org/mysql-prepared-statement.aspxhttp://www.mysqltutorial.org/mysql-temporary-table/http://www.mysqltutorial.org/mysql-temporary-table/http://www.mysqltutorial.org/mysql-temporary-table/http://www.mysqltutorial.org/mysql-prepared-statement.aspx


14/23

temporary table whose name is same as a name of a permanent table because it may lead to a confusion.For example, in case the connection to the MySQL databaseserver is lost and you reconnect to theserver automatically, you cannot differentiate between the temporary table and the permanent table. Inthe worst case, you may issue a DROP TABLE statement to remove the permanent table instead of thetemporary table, which is not expected.Create MySQL temporary tableLike the CREATE TABLE statement, MySQL provides many options to create a temporary table. To create

a temporary table, you just add the TEMPORARY keyword to the CREATE TABLE statement.For example, the following statement creates a top 10 customers by revenue temporary table based on

the result set of a SELECT statement:

123456

789

CREATE TEMPORARY TABLE top10customersSELECT p.customerNumber,

c.customerName,FORMAT(SUM(p.amount),2) total

FROM payments pINNER JOIN customers c ON c.customerNumber = p.customerNumber

GROUP BY p.customerNumberORDER BY total DESCLIMIT 10

Drop MySQL temporary tableYou can use the DROP TABLE statement to remove temporary tables however it is good practice to usethe DROP TEMPORARY TABLE statement instead. Because the DROP TEMPORARY TABLE removesonly temporary tables, not the permanent tables. In addition, the DROP TEMPORARY TABLE statement

helps you avoid the mistake of removing a permanent table when you name your temporary table thesame as the name of the permanent table.

DROP TEMPORARY TABLE top10customers

SHOW {BINARY | MASTER} LOGS

SHOW BINLOG EVENTS [IN 'log_name'] [FROMpos] [LIMIT [offset,] row_count]

SHOW CHARACTER SET [like_or_where]

SHOW COLLATION [like_or_where]

SHOW [FULL] COLUMNS FROM tbl_name[FROM db_name] [like_or_where]

SHOW CREATE DATABASEdb_name

SHOW CREATE FUNCTION func_name

SHOW CREATE PROCEDUREproc_name

SHOW CREATE TABLE tbl_name

SHOW DATABASES [like_or_where]

SHOW ENGINE engine_name{LOGS | STATUS }

SHOW [STORAGE] ENGINES

SHOW ERRORS [LIMIT [offset,] row_count]

SHOW FUNCTION CODE func_name

SHOW FUNCTION STATUS [like_or_where]

SHOW GRANTS FOR userSHOW INDEX FROM tbl_name[FROM db_name]


15/23

SHOW INNODB STATUS

SHOW PROCEDURE CODEproc_name

SHOW PROCEDURE STATUS [like_or_where]

SHOW [BDB] LOGS

SHOW MASTER STATUS

SHOW MUTEX STATUS

SHOW OPEN TABLES [FROM db_name] [like_or_where]

SHOW PRIVILEGES

SHOW [FULL] PROCESSLIST

SHOW SLAVE HOSTS

SHOW SLAVE STATUS

SHOW PROFILE [types] [FOR QUERY n] [OFFSET n] [LIMIT n]

SHOW PROFILES

SHOW [GLOBAL | SESSION] STATUS [like_or_where]

SHOW TABLE STATUS [FROM db_name] [like_or_where]

SHOW [FULL] TABLES [FROM db_name] [like_or_where]

SHOW TRIGGERS [FROM db_name] [like_or_where]

SHOW [GLOBAL | SESSION] VARIABLES [like_or_where]

SHOW WARNINGS [LIMIT [offset,] row_count]

Difference between TRUNCATE, DELETE and DROP commands

DELETEThe DELETE command is used to remove rows from a table. A WHERE clause can be used to onlyremove some rows. If no WHERE condition is specified, all rows will be removed. After performing aDELETE operation you need to COMMIT or ROLLBACK the transaction to make the change permanent orto undo it. Note that this operation will cause all DELETE triggers on the table to fire.SQL> SELECT COUNT(*) FROM emp;

COUNT(*)----------

14

SQL> DELETE FROM emp WHERE job = 'CLERK';

4 rows deleted.

SQL> COMMIT;

Commit complete.

SQL> SELECT COUNT(*) FROM emp;

COUNT(*)----------

10


16/23

TRUNCATE

TRUNCATE removes all rows from a table. The operation cannot be rolled back and no triggers will befired. As such, TRUCATE is faster and doesn't use as much undo space as a DELETE.SQL> TRUNCATE TABLE emp;

Table truncated.

SQL> SELECT COUNT(*) FROM emp;

COUNT(*)----------

0DROPThe DROP command removes a table from the database. All the tables' rows, indexes and privileges willalso be removed. No DML triggers will be fired. The operation cannot be rolled back.SQL> DROP TABLE emp;

Table dropped.

SQL> SELECT * FROM emp;

SELECT * FROM emp*ERROR at line 1:ORA-00942: table or view does not exist

DROP and TRUNCATE are DDL commands, whereas DELETE is a DML command. Therefore DELETEoperations can be rolled back (undone), while DROP and TRUNCATE operations cannot be rolled back.From Oracle 10g a table can be "undropped". Example:SQL> FLASHBACK TABLE EMP TO BEFORE DROP;

Flashback complete.PS: DROP and TRUNCATE are DDL commands, whereas DELETE is a DML command. As such, DELETEoperations can be rolled back (undone), while DROP and TRUNCATE operations cannot be rolled back.

MySQL/Language/Definitions: what are DDL, DML and DQL?

DDL (Data Definition Language) refers to the CREATE, ALTER and DROP statements

DDL allows to add / modify / delete the logical structures which contain the data or which allow users to access /

mantain the data (databases, tables, keys, views...). DDL is about "metadata".

DML (Data Manipulation Language) refers to the INSERT, UPDATE and DELETE statements

DML allows to add / modify / delete data itself.

DQL (Data Query Language) refers to the SELECT, SHOW and HELP statements (queries)

SELECT is the main DQL instruction. It retrieves data you need. SHOW retrieves infos about the metadata.

HELP... is for people who need help.

DCL (Data Control Language) refers to the GRANT and REVOKE statements

DCL is used to grant / revoke permissions on databases and their contents. DCL is simple, but MySQL's

permissions are rather complex. DCL is about security.

DTL (Data Transaction Language) refers to the START TRANSACTION, SAVEPOINT, COMMIT and

ROLLBACK [TO SAVEPOINT] statements


17/23

DTL is used to manage transactions (operations which include more instructions none of which can be executed

if one of them fails).

Granting Privileges on the new database:

-----------------------------------------------

mysql> GRANT ALL PRIVILEGES ON DatabaseName.* TO Username@localhost

or

mysql> GRANT ALL PRIVILEGES ON DatabaseName.* TO Username@localhost IDENTIFIED BY'newpassword';

mysql> GRANT SELECT,INSERT,UPDATE,DELETE ON vworks.* TO newuser@localhost IDENTIFIEDBY 'newpassword';

mysql> GRANT ALL PRIVILEGES ON DatabaseName.* TO [email protected] IDENTIFIED BY

'newpassword';

Now a user on the machine '192.168.0.2' can connect to the database. To allow a user to connectfrom anywhere you would use a wildcard '%'

mysql> GRANT ALL PRIVILEGES ON DatabaseName.* TO Username@localhost IDENTIFIED BY'newpassword' WITH GRANT OPTION;

This would allow the user 'newuser' to log into the database and give their friend privileges toSELECT,INSERT,UPDATE or DELETE from the database.

For example to REVOKE the privileges assigned to a user called 'user1':

mysql> REVOKE ALL PRIVILEGES ON DATABASENAME.* FROM user1@localhost;

Or just to remove UPDATE, INSERT and DELETE privileges to that data cannot be changed.

mysql> REVOKE INSERT,UPDATE,DELETE ON DATABASENAME.* FROM user1@localhost;

Backing Up DataBase:-------------------------

mysqlhotcopy -u -p /backup/location/

Which SHOULD copy all the tables (*.frm, *.MYI, *.MYD) into the new directory - the script doesrequire the DBI perl module though. To restore these backup files simply copy them back into yourMySQL data directory.

This is my preferred method of backing up. This outputs the table structure and data in series ofSQL commands stored in a text file. The simplified syntax is

mysqldump -u -p > file.sql

eg:

mysqldump -u user1 -p accounts > dump.sql

Restoring a DataBase from Dump:


18/23

---------------------------------------

mysqldump -u -p < file.sql

eg:

mysqldump -u user1 -p accounts < dump.sql

FLUSH PRIVILEGES;

When you create accounts withINSERT,it is necessary to useFLUSH PRIVILEGESto tell the server to reload

the grant tables. Otherwise, the changes go unnoticed until you restart the server. WithCREATE USER,FLUSH

PRIVILEGESis unnecessary.

Queries

SELECT customerNumber id, contactLastname name

FROM customers

UNION

SELECT employeeNumber id,firstname name

FROM employees

SELECT customerNumber id, contactLastname name

FROM customers

UNION all

SELECT employeeNumber id, firstname name

FROM employees

UNION removes duplicate records (where all columns in the results are the same), UNION ALL does not.

Inner join:The MySQL INNER JOIN clause matches rows in one table with rows in other tables

SELECT column_list

FROM t1

INNER JOIN t2 ON join_condition1

INNER JOIN t3 ON join_condition2

...

WHERE where_conditions;

inner join

left join

The FULL OUTER JOIN keyword returns all rows from the left table (table1) and from the right

table (table2).

The FULL OUTER JOIN keyword combines the result of both LEFT and RIGHT joins.
http://dev.mysql.com/doc/refman/5.1/en/insert.htmlhttp://dev.mysql.com/doc/refman/5.1/en/insert.htmlhttp://dev.mysql.com/doc/refman/5.1/en/insert.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/create-user.htmlhttp://dev.mysql.com/doc/refman/5.1/en/create-user.htmlhttp://dev.mysql.com/doc/refman/5.1/en/create-user.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/create-user.htmlhttp://dev.mysql.com/doc/refman/5.1/en/flush.htmlhttp://dev.mysql.com/doc/refman/5.1/en/insert.html


19/23

SQL FULL OUTER JOIN Syntax

SELECT column_name(s)FROM table1FULL OUTER JOIN table2ON table1.column_name=table2.column_name;

SELECT Customers.CustomerName, Orders.OrderIDFROM CustomersFULL OUTER JOIN OrdersON Customers.CustomerID=Orders.CustomerIDORDER BY Customers.CustomerName;

MySQL HAVING clause

SELECT ordernumber,

SUM(quantityOrdered) AS itemsCount,

SUM(priceeach) AS total

FROM orderdetails

GROUP BY ordernumber

HAVING total > 1000

UPDATE T1, T2

SET T1.c2 = T2.c2,

T2.c3 = expr

WHERE T1.c1 = T2.c1 AND condition

UPDATE T1,T2

INNER JOIN T2 ON T1.C1 = T2.C1

SET T1.C2 = T2.C2,

T2.C3 = expr

WHERE condition

UPDATE employees

INNER JOIN merits ON employees.performance = merits.performance

SET salary = salary + salary * percentage

UPDATE employees

LEFT JOIN merits ON employees.performance = merits.performance

SET salary = salary + salary * 0.015;

WHERE merits.percentage IS NULL

Delete


WHERE officeCode = 4


DELETE employees,

offices

FROM employees,

offices

WHERE employees.officeCode = offices.officeCode AND

offices.officeCode = 1


20/23

DELETE FROM employees, offices

USING employees, offices

WHERE employees.officeCode = offices.officeCode AND

offices.officeCode = 1

Truncate-truncate table categories

ReplaceREPLACE INTO categories(categoryname,categoryid)VALUES('PQR','4');

RDBMS

RDBMS stands for Relational Database Management System.

RDBMS is the basis for SQL, and for all modern database systems such as MS SQL Server, IBMDB2, Oracle, MySQL, and Microsoft Access.

The data in RDBMS is stored in database objects called tables.

A table is a collection of related data entries and it consists of columns and rows.

What is SQL?

SQL stands for Structured Query Language

SQL lets you access and manipulate databases SQL is an ANSI (American National Standards Institute) standard

SELECT DISTINCT City FROM Customers;

SELECT * FROM Customers WHERE Country='Germany' AND City='Berlin';

SELECT * FROM Customers WHERE City='Berlin' OR City='Mnchen';

SELECT * FROM Customers WHERE Country='Germany' AND (City='Berlin' OR

city='Mnchen');

SELECT * FROM Persons LIMIT 5;

SELECT * FROM Persons WHERE ROWNUM


21/23

SELECT * FROM Customers WHERE City LIKE 'ber%' ;

SELECT * FROM Customers WHERE City LIKE '_erlin'; (The following SQL statement

selects all customers with a City starting with any character, followed by "erlin")

SELECT * FROM Customers WHERE City LIKE 'L_n_on'; (The following SQL statement

selects all customers with a City starting with "L", followed by any character, followedby "n", followed by any character, followed by "on")

SELECT * FROM Customers WHERE City LIKE '[bsp]%'; (The following SQL statement

selects all customers with a City starting with "b", "s", or "p")

SELECT * FROM Customers WHERE City LIKE '[a-c]%'; (The following SQL statement

selects all customers with a City starting with "a", "b", or "c")

SELECT * FROM Customers WHERE City LIKE '[!bsp]%'; (The following SQL statement

selects all customers with a City NOT starting with "b", "s", or "p")

SQL UNION Example

The following SQL statement selects all the differentcities (only distinct values) from the

"Customers" and the "Suppliers" tables:

SELECT City FROM Customers

UNION

SELECT City FROM Suppliers

ORDER BY City;

The following SQL statement uses UNION ALL to select all(duplicate values also) cities from the

"Customers" and "Suppliers" tables:SELECT City FROM Customers

UNION ALL

SELECT City FROM Suppliers

ORDER BY City;

The following SQL statement uses UNION ALL to select all(duplicate values also) Germancities

from the "Customers" and "Suppliers" tables:

SELECT City, Country FROM Customers

WHERE Country='Germany'

UNION ALL

SELECT City, Country FROM SuppliersWHERE Country='Germany'

ORDER BY City;

SQL SELECT INTO Examples

Create a backup copy of Customers:

SELECT *

INTO CustomersBackup2013

FROM Customers;

Use the IN clause to copy the table into another database:


22/23

SELECT *

INTO CustomersBackup2013 IN 'Backup.mdb'

FROM Customers;

Copy only a few columns into the new table:

SELECT CustomerName, ContactNameINTO CustomersBackup2013

FROM Customers;

Copy only the German customers into the new table:

SELECT *

INTO CustomersBackup2013

FROM Customers

WHERE Country='Germany';

Copy data from more than one table into the new table:

SELECT Customers.CustomerName, Orders.OrderID

INTO CustomersOrderBackup2013

FROM Customers

LEFT JOIN Orders

ON Customers.CustomerID=Orders.CustomerID;

Tip: The SELECT INTO statement can also be used to create a new, empty table using the

schema of another. Just add a WHERE clause that causes the query to return no data:

SELECT *

INTO newtable

FROM table1

WHERE 1=0;

SQL INSERT INTO SELECT ExamplesINSERT INTO Customers (CustomerName, Country)SELECT SupplierName, Country FROM Suppliers WHERE

Country='Germany';

NULL Function

MySQL does have an ISNULL() function. However, it works a little bit different from Microsoft's

ISNULL() function.

In MySQL we can use the IFNULL() function, like this:

SELECT ProductName,UnitPrice*(UnitsInStock+IFNULL(UnitsOnOrder,0))

FROM Products

or we can use the COALESCE() function, like this:

SELECT ProductName,UnitPrice*(UnitsInStock+COALESCE(UnitsOnOrder,0))

FROM Products


23/23

Documents

MySQL Development.docx