Advanced MySQL

Administration and
Programming
Khalilullah Akbari
Khalil.akbari18@gmail.com
+93 729908855
Optimizing database
Optimizing your MySQL database isn’t a simple process, but it’s vital for maintaining
application performance and service delivery.

1. Understand Your Workload

2. Optimize Queries
3. Don’t Use MySQL as a Queue
4. Monitor the Fundamental Resources
5. Filter Results
6. Optimize Subqueries
7. Recognize Scalability Problems
8. Query the Cache
9. Check Pagination Queries
Backing up and restoring MySQL database
Backup and restoration of MySQL databases play a very important role in a
production environment, so here is a simple method to backup a MySQL database.

To backup MySQL database(s), the following command can be used:

# mysqldump --user=username --password=password --opt DatabaseName > database.sql

Restoring the MySQL database
To restore a saved MySQL database, the following sequence can be used.

If the database is created, restore the database using:

# mysql --user=username --password=password DatabaseName < backup_filename.sql

MySQL replication
MySQL replication is a process that enables data
from one MySQL database server (the master) to be
copied automatically to one or more MySQL
database servers (the slaves). It is usually used to
spread read access on multiple servers for
scalability, although it can also be used for other
purposes such as for failover, or analyzing data on
the slave in order not to overload the master.
LOAD DATA INFILE
To load content of a file into a mysql database, follow the following steps:

Locate the file contain your data

Run the following command

LOAD DATA LOCAL INFILE '<file-name>'

INTO table <table-name>
FIELDS TERMINATED BY ',' ENCLOSED BY ‘“’;
Storage Engines
MySQL table types/storage engines are essential features that can be used effectively
for maximizing the database's performance.

mysql> SHOW ENGINES;

Storage Engines
The following are various table types/storage engines supports in MySQL:
ISAM
MyISAM
MERGE
InnoDB
MEMORY (HEAP)
ARCHIVE
BDB
CSV
FEDERATED
Storage Engines
ISAM Table
It is abbreviated as Indexed Sequential Access Method. This table type/storage
engine has been deprecated and removed from MySQL version 5.x. MyISAM now
replaces the functionalities of this table. The size of an ISAM table is 4 GB

MyISAM Table
It is an extension of the ISAM storage engine. The MyISAM table size is dependent
on the OS and can be up to 256 TB
Storage Engines
InnoDB Table
The InnoDB tables in MySQL fully support transaction-safe storage engine with
ACID-compliant. It is the first table type that supports foreign keys. The InnoDB
tables also provide optimal performance. Its size can be up to 64TB.

Advantages of InnoDB
InnoDB provides optimal performance while processing a large amount of data.
InnoDB tables arrange our data on the disk based on the primary key.
Disadvantages of InnoDB
InnoDB tables take more space on disk in comparison with MyISAM.
Storage Engines
MERGE Table
MERGE table is also known as MRG_MyISAM. This table combines multiple
MyISAM tables with a similar structure (identical column and index information
with the same order) into a single table. This table uses indexes of the component
tables because it does not have its own indexes. When we join multiple tables, it
can also be used to speed up the database's performance. We can perform only
INSERT, SELECT, DELETE, and UPDATE operations on the MERGE tables.
Storage Engines
Memory Table
The memory table type/storage engine creates tables, which will be stored in our
memory. It is also known as HEAP before MySQL version 4.1. This table type is
faster than MyISAM because it uses hash indexes that retrieve results faster.

CSV Table
The CSV table type/storage engine stores data in comma-separated values in a file.
It provides a convenient way to migrate data into many different software
packages, such as spreadsheet software. This table type is not as good as a general
database engine; however, it enables us to exchange our data most effectively and
easily.
Storage Engines
FEDERATED Table
The FEDERATED table type/storage engine supports MySQL from version 5.03 that
allows access data from a remote MySQL server without using the
cluster/replication technology. The federated storage engine located in local
storage does not store any data. If we will query data from a federated table
stored in local memory, MySQL automatically pulled data from the remote
federated tables.
ARCHIVE Table
This table type/storage engine allows us to store a large volume of data in a
compressed format to save disk space and cannot be modified. Thus, it is the
perfect storage engine to store log data that is no longer in active use, such as the
old invoice or sales data.
Transaction
A transaction in MySQL is a sequential group of statements, queries, or operations
such as select, insert, update or delete to perform as a one single work unit that can
be committed or rolled back.

A transaction in MySQL starts with the first executable SQL statement and ends
when it finds a commit or rolled back either explicitly or implicitly.
Transaction
Properties of Transaction
The transaction contains mainly four properties, which referred to
as ACID property

1. Atomicity
2. Consistency
3. Isolation
4. Durability
Transaction
Atomicity:
This property ensures that all statements or operations within the transaction unit
must be executed successfully. Otherwise, if any operation is failed, the whole
transaction will be aborted, and it goes rolled back into their previous state.

COMMIT statement.
ROLLBACK statement.
Auto-commit setting.
Transaction
Consistency:
This property ensures that the database changes state only when a transaction will
be committed successfully. It is also responsible for protecting data from crashes.

InnoDB doublewrite buffer.

InnoDB crash recovery.
Transaction
Isolation:
This property guarantees that each operation in the transaction unit operated
independently. It also ensures that statements are transparent to each other.

Durability:
This property guarantees that the result of committed transactions persists
permanently even if the system crashes or failed.
Transaction
MySQL Transaction Statement
MySQL provides a START TRANSACTION statement to begin the transaction. It also
offers a "BEGIN" and "BEGIN WORK" as an alias of the START TRANSACTION.
We will use a COMMIT statement to commit the current transaction. It allows the
database to make changes permanently.
We will use a ROLLBACK statement to roll back the current transaction. It allows
the database to cancel all changes and goes into their previous state.
We will use a SET auto-commit statement to disable/enable the auto-commit
mode for the current transaction. By default, the COMMIT statement executed
automatically.
Transaction
SET autocommit = 0/OFF
SET autocommit = 1/ON
Commit Example
-- 1. Start a new transaction
START TRANSACTION;

-- 2. Get the highest income

SELECT * FROM employees;

-- 3. Insert a new record into the employee table

INSERT INTO employees(emp_id, emp_name, emp_age, city, income)
VALUES (111, 'Alexander', 45, 'California', 70000);

-- 4. Insert a new record into the order table

INSERT INTO Orders(order_id, prod_name, order_num, order_date)
VALUES (6, 'Printer', 5654, '2020-01-10');

-- 5. Commit changes
COMMIT;
ROLLBACK Example
-- 1.
START TRANSACTION;

-- 2. Delete data from the order table

DELETE FROM Orders;

SELECT * FROM Orders;

-- 3. Rollback changes
ROLLBACK;

-- 4. Verify the records in the first session

SELECT * FROM Orders;
Transaction
SAVEPOINT, ROLLBACK TO SAVEPOINT
The SAVEPOINT statement creates a special mark with the name of
the identifier inside a transaction. It allows all statements that are executed after
savepoint would be rolled back. So that the transaction restores to the previous
state it was in at the point of the savepoint. If we have set multiple savepoints in
the current transaction with the same name, the newly savepoint is responsible
for rollback.
Example
START TRANSACTION;

SELECT * FROM Orders;

INSERT INTO Orders(order_id, prod_name, order_num, order_date) VALUES (6, 'Printer', 5654, '2020-01-10');

SAVEPOINT my_savepoint;

INSERT INTO Orders(order_id, prod_name, order_num, order_date) VALUES (7, 'Ink', 5894, '2020-03-10');

ROLLBACK TO SAVEPOINT my_savepoint;

INSERT INTO Orders(order_id, prod_name, order_num, order_date) VALUES (8, 'Speaker', 6065, '2020-02-18');

COMMIT;
Stored Procedure
A procedure (often called a stored procedure) is a collection of pre-compiled SQL
statements stored inside the database. It is a subroutine or a subprogram in the
regular computing language.
A procedure always contains a name, parameter lists, and SQL statements.

A procedure is called a recursive stored procedure when it calls itself. Most database
systems support recursive stored procedures. But, it is not supported well in MySQL.
Stored Procedure
Stored Procedure Features
Stored Procedure increases the performance of the applications.
Stored procedure reduces the traffic between application and database server.
Because the application has to send only the stored procedure's name and
parameters instead of sending multiple SQL statements.
Stored procedures are reusable and transparent to any applications.
A procedure is always secure. The database administrator can grant permissions to
applications that access stored procedures in the database without giving any
permissions on the database tables.
Stored Procedure
Create a procedure
It can return one or more value through parameters or sometimes may not return
at all. By default, a procedure is associated with our current database. But we can
also create it into another database from the current database by specifying the
name as database_name.procedure_name.
DELIMITER &&
CREATE PROCEDURE procedure_name [[IN | OUT | INOUT] parameter_name datatype [, parameter datatype]) ]

BEGIN
Declaration_section
Executable_section
END &&
DELIMITER ;
Stored Procedure
Parameter Explanations

Parameter Name Descriptions

procedure_name It represents the name of the stored procedure.

parameter It represents the number of parameters. It can be

one or more than one.

Declaration_section It represents the declarations of all variables.

Executable_section It represents the code for the function execution.

Stored Procedure
IN parameter
It is the default mode. It takes a parameter as input, such as an attribute. When
we define it, the calling program has to pass an argument to the stored procedure.
This parameter's value is always protected.
OUT parameters
It is used to pass a parameter as output. Its value can be changed inside the stored
procedure, and the changed (new) value is passed back to the calling program. It is
noted that a procedure cannot access the OUT parameter's initial value when it
starts.
INOUT parameters
It is a combination of IN and OUT parameters.
Stored Procedure
Call a stored procedure
We can use the CALL statement to call a stored procedure. This statement returns
the values to its caller through its parameters (IN, OUT, or INOUT). The following
syntax is used to call the stored procedure in MySQL:

CALL procedure_name ( parameter(s))

Stored Procedure
Procedure without Parameter
DELIMITER &&
CREATE PROCEDURE get_merit_student ()
BEGIN
SELECT * FROM student_info WHERE marks > 70;
SELECT COUNT(stud_code) AS Total_Student FROM student_info;
END &&
DELIMITER ;

CALL get_merit_student();
Stored Procedure
Procedures with IN Parameter
In this procedure, we have used the IN parameter as 'var1' of integer type to accept a
number from users. Its body part fetches the records from the table using
a SELECT statement. and returns only those rows that will be supplied by the user.
DELIMITER &&
CREATE PROCEDURE get_student (IN var1 INT)
BEGIN
SELECT * FROM student_info LIMIT var1;
SELECT COUNT(stud_code) AS Total_Student FROM student_info;
END &&
DELIMITER ;
CALL get_student(4);
Stored Procedure
Procedures with OUT Parameter
This procedure's parameter will get the highest marks from the student_info table. When we call the
procedure, the OUT parameter tells the database systems that its value goes out from the procedures.

DELIMITER &&
CREATE PROCEDURE display_max_mark (OUT highestmark INT)
BEGIN
SELECT MAX(marks) INTO highestmark FROM student_info;
END &&
DELIMITER ;

mysql> CALL display_max_mark(@M);

mysql> SELECT @M;
Stored Procedure
Procedures with INOUT Parameter
In this procedure, we have used the INOUT parameter as 'var1' of integer type. Its body part first
fetches the marks from the table with the specified id and then stores it into the same variable
var1.
DELIMITER &&
CREATE PROCEDURE display_marks (INOUT var1 INT)
BEGIN
SELECT marks INTO var1 FROM student_info WHERE stud_id = var1;
END &&
DELIMITER ;
mysql> SET @M = '3';
mysql> CALL display_marks(@M);
mysql> SELECT @M;
Thank You