# MySQL Tutorial: An In-Depth Guide
## Introduction to MySQL
MySQL is an open-source relational database management system (RDBMS) that uses
Structured Query Language (SQL) for managing and manipulating data. It is one of
the most popular databases used by developers and enterprises worldwide due to its
reliability, scalability, and ease of use. MySQL supports large-scale applications,
including websites, enterprise software, and data analytics systems.
### Key Features of MySQL
* **Open-source**: MySQL is freely available under the GNU General Public License
(GPL).
* **Cross-platform**: It works on Windows, Linux, macOS, and other operating
systems.
* **Scalable**: It supports small to large applications and can scale with high-
demand systems.
* **ACID-compliant**: Ensures data integrity and reliability with support for
transactions.
* **Replication**: Supports master-slave replication for high availability and data
redundancy.
* **Clustered Architecture**: Enables high availability and load balancing through
clustering.
## Installation and Setup
Before diving into SQL queries and database management, the first step is
installing MySQL. The installation process can vary depending on the operating
system you are using.
### Installation on Windows
1. **Download MySQL Installer**: Visit the [MySQL download
page](https://dev.mysql.com/downloads/installer/) and download the MySQL Installer
for Windows.
2. **Run the Installer**: After downloading, run the installer and select the
appropriate version of MySQL server to install.
3. **Choose Configuration**: During the installation process, you'll be prompted to
configure MySQL server settings, including the root password and port number.
4. **Start MySQL Server**: Once installation is complete, start the MySQL server
and open the MySQL Workbench to manage databases.
### Installation on macOS
1. **Homebrew Installation**: If you have Homebrew installed, you can install MySQL
with the following command:
```bash
brew install mysql
```
2. **Start MySQL**: After installation, start MySQL with:
```bash
brew services start mysql
```
3. **Secure MySQL Installation**: Run the following command to configure security
settings:
```bash
mysql_secure_installation
```
### Installation on Linux
1. **Using APT (Debian/Ubuntu)**:
```bash
sudo apt update
sudo apt install mysql-server
sudo mysql_secure_installation
```
2. **Start MySQL**:
```bash
sudo systemctl start mysql
sudo systemctl enable mysql
```
After installation, you can interact with MySQL through the command line by running
`mysql -u root -p` and entering your root password.
## Basic MySQL Commands
Now that MySQL is installed, it's time to explore the basic commands used for
managing databases, tables, and data.
### Connecting to MySQL
To start using MySQL, open your terminal or command prompt and enter the following
command:
```bash
mysql -u root -p
```
This command will prompt you to enter the root password for authentication. Once
authenticated, you will enter the MySQL shell.
### Showing Databases
Once logged in, you can view all the databases on your MySQL server by using:
```sql
SHOW DATABASES;
```
### Creating a Database
To create a new database, use the `CREATE DATABASE` command:
```sql
CREATE DATABASE my_database;
```
To switch to a specific database, use the `USE` command:
```sql
USE my_database;
```
### Creating Tables
After selecting a database, you can create tables to store data. Here’s an example
of creating a simple `users` table:
```sql
CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100),
email VARCHAR(100),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
### Inserting Data
To insert data into a table, use the `INSERT INTO` command:
```sql
INSERT INTO users (name, email)
VALUES ('John Doe', '[email protected]');
```
### Selecting Data
To retrieve data from a table, use the `SELECT` statement:
```sql
SELECT * FROM users;
```
You can also filter results using `WHERE`:
```sql
SELECT * FROM users WHERE name = 'John Doe';
```
### Updating Data
To modify existing records, use the `UPDATE` statement:
```sql
UPDATE users
SET email = '[email protected]'
WHERE name = 'John Doe';
```
### Deleting Data
To delete records from a table, use the `DELETE` statement:
```sql
DELETE FROM users WHERE name = 'John Doe';
```
### Dropping Tables and Databases
To remove a table or database, use the `DROP` command:
```sql
DROP TABLE users;
DROP DATABASE my_database;
```
## Data Types in MySQL
MySQL supports several data types, each used for different purposes. The major
categories of data types are:
### Numeric Data Types
* **INT**: A standard integer, which can be signed or unsigned.
* **TINYINT**: A small integer.
* **BIGINT**: A large integer.
* **FLOAT**: Single precision floating-point numbers.
* **DOUBLE**: Double precision floating-point numbers.
* **DECIMAL**: Exact numeric values with a specified number of digits.
### String Data Types
* **VARCHAR**: Variable-length string.
* **CHAR**: Fixed-length string.
* **TEXT**: Used for large text data.
* **BLOB**: Binary Large Object, used for storing binary data.
### Date and Time Data Types
* **DATE**: A date in the format `YYYY-MM-DD`.
* **DATETIME**: A date and time value in the format `YYYY-MM-DD HH:MM:SS`.
* **TIMESTAMP**: A timestamp value.
* **TIME**: A time value.
### Boolean Data Type
* **BOOLEAN**: A value that can be either `TRUE` (1) or `FALSE` (0).
## MySQL Queries and Clauses
### WHERE Clause
The `WHERE` clause is used to filter records based on specific conditions. You can
use operators like `=`, `!=`, `>`, `<`, `IN`, `LIKE`, and `BETWEEN` to refine the
conditions.
Example:
```sql
SELECT * FROM users WHERE email LIKE '%example.com';
```
### ORDER BY Clause
The `ORDER BY` clause sorts the result set in ascending or descending order. By
default, it sorts in ascending order.
```sql
SELECT * FROM users ORDER BY name ASC;
```
### LIMIT Clause
To restrict the number of rows returned by a query, you can use the `LIMIT` clause:
```sql
SELECT * FROM users LIMIT 5;
```
### GROUP BY and HAVING Clauses
The `GROUP BY` clause is used to group rows with similar values, typically for
aggregation purposes (e.g., SUM, AVG, COUNT). The `HAVING` clause filters groups
based on a condition.
Example:
```sql
SELECT name, COUNT(*) AS user_count
FROM users
GROUP BY name
HAVING COUNT(*) > 1;
```
## Advanced MySQL Concepts
### Joins
A **join** is used to combine rows from two or more tables based on a related
column. There are different types of joins:
* **INNER JOIN**: Returns only rows that have matching values in both tables.
* **LEFT JOIN**: Returns all rows from the left table and matching rows from the
right table.
* **RIGHT JOIN**: Returns all rows from the right table and matching rows from the
left table.
* **FULL JOIN**: Returns all rows from both tables, with NULL values for non-
matching rows.
Example of an `INNER JOIN`:
```sql
SELECT users.name, orders.order_id
FROM users
INNER JOIN orders ON users.id = orders.user_id;
```
### Subqueries
A **subquery** is a query nested inside another query. It can be used in `SELECT`,
`INSERT`, `UPDATE`, or `DELETE` statements.
Example:
```sql
SELECT name
FROM users
WHERE id IN (SELECT user_id FROM orders WHERE amount > 100);
```
### Indexes
Indexes are used to speed up the retrieval of rows by creating a pointer to the
data. They are commonly created on columns that are frequently searched or used in
joins.
Example:
```sql
CREATE INDEX idx_name ON users (name);
```
### Transactions
Transactions are used to ensure that multiple operations are performed as a single
unit. If any operation fails, all changes are rolled back.
To start a transaction:
```sql
START TRANSACTION;
```
To commit changes:
```sql
COMMIT;
```
To roll back changes:
```sql
ROLLBACK;
```
### Foreign Keys
A **foreign key** is a column or group of columns in one table that uniquely
identifies a row of another table. It is used to enforce referential integrity.
Example:
```sql
CREATE TABLE orders (
order_id INT AUTO_INCREMENT PRIMARY KEY,
user_id INT,
FOREIGN KEY (user_id) REFERENCES users(id)
);
```
### Views
A **view** is a virtual table based on the result of a query. It doesn’t store data
itself but presents data from one or more tables.
Example:
```sql
CREATE VIEW user_orders AS
SELECT users.name, orders.order_id
FROM users
INNER JOIN orders ON users.id = orders.user_id;
```
### Stored Procedures
A **stored procedure** is a set of SQL statements that can be executed as a single
unit. They are used to store.
