Sign In
Sign In

MySQL Basics

MySQL Basics
Hostman Team
Technical writer
MySQL
13.06.2024
Reading time: 7 min

MySQL is a free database management system that uses the SQL language. Its popularity is due to its support for virtually all platforms and operating systems. MySQL can be deployed locally on your Windows, Linux, or macOS machine, on a cloud server, or as a cloud database

In this MySQL tutorial, we will give a general overview of MySQL installation and data structure, as well as provide basic MySQL commands for working with data.

Key Points

The latest version of MySQL is available on the official website: https://dev.mysql.com/downloads/mysql/

Before downloading, you will be prompted to log in with an Oracle account, but this is optional. Files are available to unauthenticated users as well. 

During installation, just follow the installer prompts. For example, you need to specify which components you need or select the maximum platform package.

Installation Options:

  • Developer is a platform for developers, which includes special tools.

  • Server Only installs only the server part of MySQL.

  • Client Only installs only the client MySQL module.

  • Full installs all components included in the installer.

  • Custom allows for selective installation and is suitable for advanced users.

The basics of working with MySQL include installation, platform configuration, creating a local or remote database, and connecting to existing databases. When managing databases in MySQL, you need an understanding of how to input and update information, create backups, and restore data. Tools like MySQL Workbench provide a GUI and significantly simplify working with the system.

One of the important points of MySQL installation includes creating a user. The administrator account is created first. Later, you can add and additional delete accounts. An example of creating a user looks like this:

CREATE USER ‘hostman’@'localhost' IDENTIFIED BY 'password';

Data Structure

Working with MySQL involves working with two logical blocks: server and client. The server block includes the MySQL database itself, which will then be managed. Technically, it is a set of files with FRM, MYD, MYI extensions. Each database contains one or more tables used for structured data storage. Depending on the volume of information, one or more records are added to the database.

The database structure is the same regardless of the project where it is used.

The client part usually consists of PHP scripts designed to receive data from external sources, process it, and send it to the server or retrieve previously stored information for display and various calculations. A typical example is that website content (texts, image links, animations, and other elements) is stored in a connected database. When a page is opened, it is retrieved according to the specified program.

The core of the database structure is tables. They consist of fields with a specific ID number. Table names usually correspond to their contents, for example, the USER block contains information about registered users. In this case, the fields store login, password, name, email address, and other details. These data are distributed across individual records – these are cells filled with values according to the assigned data type.

Basic Commands

The basic MySQL commands include creating databases and tables within them, adding and retrieving data, filtering, updating, and deleting data. This set is sufficient for a website or any other cloud resource to function fully.

Below are examples of basic SQL queries for performing operations with data and examples of how to implement those functions with Node.js.

Creating a database

Let's create a database named hostmandb.

SQL:

CREATE DATABASE hostmandb; 

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
password: "mysecurepass"
});
connection.query("CREATE DATABASE hostmandb",
function(err, results) {
if(err) console.log(err);
else console.log("Database created");
});
connection.end();

Creating a table

Let's create a users table in our hostmandb database.

SQL:

CREATE TABLE users ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), age INT ); 

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
database: "hostmandb",
password: "mysecurepass"
});
const sql = `create table if not exists users(
id int primary key auto_increment,
name varchar(255) not null,
age int not null
)`;
connection.query(sql, function(err, results) {
if(err) console.log(err);
else console.log("Table created");
});
connection.end();

Inserting data

Now let's insert data into the users table.

SQL:

INSERT INTO users(name, age) VALUES('Sam', 31);

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
database: "hostmandb",
password: "mysecurepass"
});
const sql = `INSERT INTO users(name, age) VALUES('John', 41)`;
connection.query(sql, function(err, results) {
if(err) console.log(err);
console.log(results);
});
connection.end();

Querying data

Let's request all data from the users table.

SQL:

SELECT * FROM users;

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
database: "hostmandb",
password: "mysecurepass"
});
const sql = `SELECT * FROM users`;
connection.query(sql, function(err, results) {
if(err) console.log(err);
console.log(results);
});
connection.end();

Filtering query results

Let's request the data and filter it by name and age.

SQL:

SELECT * FROM users WHERE name=John AND age=41;

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
database: "hostmandb",
password: "mysecurepass"
});
const sql = `SELECT * FROM users WHERE name=? AND age=?`;
const filter = ["John", 41];
connection.query(sql, filter, function(err, results) {
if(err) console.log(err);
console.log(results);
});
connection.end();

Updating data

SQL:

UPDATE users SET age = 35 WHERE name = 'Jenny'; 

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
database: "hostmandb",
password: "mysecurepass"
});
const sql = `UPDATE users SET age=? WHERE name=?`;
const data = [35, "Jenny"];
connection.query(sql, data, function(err, results) {
if(err) console.log(err);
console.log(results);
});
connection.end();

Deleting data

SQL:

DELETE FROM users WHERE name = John; 

Node.js:

const mysql = require("mysql2");
const connection = mysql.createConnection({
host: "localhost",
user: "root",
database: "hostmandb",
password: "mysecurepass"
});
const sql = "DELETE FROM users WHERE name=?";
const data = ["John"]; // deleting users with the name John
connection.query(sql, data, function(err, results) {
if(err) console.log(err);
console.log(results);
});
connection.end();

More queries examples

Queries are divided into simple and complex based on their application. Simple ones involve interaction with just one table. Complex ones are designed to handle data streams from two or more tables.

Simple Queries:

  • SELECT is designed to read data from the database.

Output the number of records in the table:

SELECT count(*) FROM table_name;

Select all records from the table:

SELECT * FROM table_name;

Selects 3 records from the table, starting from the second one:

SELECT * FROM table_name LIMIT 2,3;
  • UPDATE allows you to change data previously saved in the database.

Change the value of the site field to domain.com in the table table_name with ID=3:

UPDATE table_name set site = 'domain.com' where id = '3';
  • DELETE deletes records from specified tables.

Clear the record from table_name with ID=2:

DELETE from table_name where id = '2';

Complex queries are longer since they are designed to work with multiple tables. Here's an example:

SELECT DISTINCT last_name FROM person p, address adr WHERE p.adress_no = adr.address_no AND city LIKE 'L%';

This will display all unique last names of people living in a city starting with L. The format is not strict, so you often see code identical in execution but different in structure. The query:

SELECT DISTINCT last_name FROM person, address WHERE person.adress_no = address.address_no AND city LIKE 'L%';

will display the same information as the previous one, although their syntax differs slightly. Despite the name, complex queries only appear complex. You simply need to understand the data processing logic and consistently include it in the code.

Conclusion

In this tutorial, we went over MySQL basics and provided example queries for working with a MySQL database.

For a deeper dive, we recommend checking the official MySQL documentation

 

MySQL
13.06.2024
Reading time: 7 min

Similar

MySQL

How to Find and Delete Duplicate Rows in MySQL with GROUP BY and HAVING Clauses

Duplicate entries may inadvertently accumulate in databases, which are crucial for storing vast amounts of structured data. These duplicates could show up for a number of reasons, including system errors, data migration mistakes, or repeated user submissions. A database with duplicate entries may experience irregularities, sluggish performance, and erroneous reporting. Using the GROUP BY and HAVING clauses, as well as a different strategy that makes use of temporary tables, we will discuss two efficient methods for locating and removing duplicate rows in MySQL. With these techniques, you can be sure that your data will always be accurate, clean, and well-organized. Database duplication in MySQL tables can clog your data, resulting in inaccurate analytics and needless storage. Locating and eliminating them is a crucial database upkeep task. This is a detailed guide on how to identify and remove duplicate rows. If two or more columns in a row have identical values, it is called a duplicate row. For instance, rows that have the same values in both the userName and userEmail columns of a userDetails table may be considered duplicates. Benefits of Removing Duplicate Data The advantage of eliminating duplicate data is that duplicate entries can slow down query performance, take up extra storage space, and produce misleading results in reports and analytics. The accuracy and speed of data processing are improved by keeping databases clean, which is particularly crucial for databases that are used for critical applications or are expanding. Requirements Prior to starting, make sure you have access to a MySQL database or have MySQL installed on your computer. The fundamentals of general database concepts and SQL queries. One can execute SQL commands by having access to a MySQL client or command-line interface. To gain practical experience, you can create a sample database and table that contains duplicate records so that you can test and comprehend the techniques for eliminating them. Creating a Test Database Launch the MySQL command-line tool to create a Test Database. mysql -u your_username -p Create a new database called test_dev_db after entering your MySQL credentials. CREATE DATABASE test_dev_db; Then, switch to this newly created database:. USE test_dev_db; Add several rows, including duplicates, to the userDetails table after creating it with the CREATE TABLE query and INSERT query below. CREATE TABLE userDetails ( userId INT AUTO_INCREMENT PRIMARY KEY, userName VARCHAR(100), userEmail VARCHAR(100) ); INSERT INTO userDetails (userName, userEmail) VALUES (‘Alisha’, ‘[email protected]’), (‘Bobita, ‘[email protected]’), (‘Alisha’, ‘[email protected]’), (‘Alisha’, ‘[email protected]’); Using GROUP BY and HAVING to Locate Duplicates Grouping rows according to duplicate-defining columns and using HAVING to filter groups with more than one record is the simplest method for finding duplicates. Now that you have duplicate data, you can use SQL to determine which rows contain duplicate entries. MySQL's GROUP BY and HAVING clauses make this process easier by enabling you to count instances of each distinct value. An example of a table structure is the userDetails table, which contains the columns userId, userName, and userEmail. The GROUP BY clause is useful for counting occurrences and identifying duplicates because it groups records according to specified column values. The HAVING clause  allows duplicate entries in groups formed by GROUP BY to be found by combining groups based on specific criteria. Table userDetails Structure userId userName userEmail 1 Alisha  [email protected] 2 Bobita  [email protected] 3 Alisha  [email protected] 4 Alisha  [email protected] In the above table userDetails, records with identical userName and userEmail values are considered duplicates. Finding Duplicates Query for find the duplicate entries: SELECT userName, userEmail, COUNT(*) as count FROM userDetails GROUP BY userName, userEmail HAVING count > 1; Rows are grouped by userName and userEmail in the aforementioned query, which also counts entries within the group and eliminates groups with a single entry (no duplicates). Explanation: SELECT userName, userEmail, COUNT(*) as count: Retrieves the count of each combination of username and userEmail, as well as their unique values. GROUP BY userName, userEmail: Records are grouped by username and user email using the GROUP BY userName, userEmail function COUNT (*): Tallies the rows in each set. HAVING occurrences > 1: Recurring entries are identified by displaying only groups with more than one record. This query will return groups of duplicate records based on the selected columns. userName userEmail count Alisha [email protected] 3 Eliminating Duplicate Rows After finding duplicates, you may need to eliminate some records while keeping the unique ones. Joining the table to itself and removing rows with higher userId values is one effective method that preserves the lowest userId for every duplicate. Use the SQL query to remove duplicate rows while keeping the lowest userId entry. DELETE u1 FROM userDetails u1 JOIN userDetails u2 ON u1. userName = u2. userName AND u1. userEmail = u2. userEmail AND u1. userId > u2. userId ; Explanation: u1 & u2: Aliases for the userDetails table to ease a self-join. ON u1. userName = u2. userName AND u1. userEmail = u2. userEmail: Matches rows with identical userName, userEmail. AND u1. userId > u2. userId: Removes rows with higher userId values, keeping only the row with the smallest userId. Because this action cannot be undone, it is advised that you backup your data before beginning the deletion procedure. Confirming Duplicate Removal To confirm that all duplicates have been removed, repeat the Step 1 identification query. SELECT userName, userEmail, COUNT(*) as count FROM userDetails GROUP BY userName, userEmail HAVING count > 1; All duplicates have been successfully eliminated if this query yields no rows. Benefits of Employing GROUP BY and HAVING The GROUP BY and HAVING clauses serve as vital instruments for the aggregation of data and the filtration of grouped outcomes. These functionalities are especially useful for detecting and handling duplicate entries or for condensing extensive datasets. Below are the primary benefits of employing these clauses. Efficient Identification of Duplicates Data Aggregation and Summarization Filtering Aggregated Results with Precision Versatility Across Multiple Scenarios Compatibility and Simplicity Enhanced Query Readability Support for Complex Aggregations The GROUP BY and HAVING clauses serve as essential instruments for data aggregation, identifying duplicates, and filtering results. Their effectiveness, ease of use, and adaptability render them crucial for database management and data analysis activities, allowing users to derive insights and handle data proficiently across a variety of applications. Identifying Duplicates Using a Temporary Table When dealing with large datasets, it can be easier and more efficient to separate duplicates using a temporary table before deleting them. Creating the Table Make a temporary table to store duplicate groups according to predetermined standards (e.g. A. username, along with userEmail. CREATE TEMPORARY TABLE temp_view_duplicates AS SELECT username, userEmail, MIN (userId) AS minuid FROM userDetails GROUP BY username, userEmail, HAVING COUNT(*) > 1; Explanation: CREATE TEMPORARY TABLE temp_view_duplicates AS: Creates a temporary table named temp_view_duplicates. SELECT userName, userEmail, MIN(userId) AS minuid: Groups duplicates by userName and userEmail, keeping only the row with the smallest userId. GROUP BY userName, userEmail: Groups rows by userName, userEmail. HAVING COUNT(*) > 1: Filters only groups with more than one row, identifying duplicates. This temporary table will now contain one representative row per duplicate group (the row with the smallest id). Deleting Duplicates from the Main Table Now that we have a list of unique rows with duplicates in the temp_view_duplicates table, we can use the temporary table to remove duplicates while keeping only the rows with the smallest userId. Use the following DELETE command: DELETE FROM userDetails WHERE (username, userEmail) IN ( SELECT username, userEmail FROM temp_view_duplicates ) AND userId NOT IN ( SELECT minuid FROM temp_view_duplicates ); Explanation: WHERE (username, userEmail,) IN: Targets only duplicate groups identified in temp_view_duplicates. AND userId NOT IN (SELECT minuid FROM temp_view_duplicates): Ensures that only duplicate rows (those with higher userId values) are deleted. Verifying Results To confirm that duplicates have been removed, query the userDetails table: SELECT * FROM userDetails; Only unique rows should remain. Temporary tables (CREATE TEMPORARY TABLE) are automatically dropped when the session ends, so they don’t persist beyond the current session. When making extensive deletions, think about utilizing a transaction to safely commit or undo changes as necessary. Key Advantages of Using a Temporary Table Lower Complexity: By isolating duplicates, the removal process is simpler and clearer. Enhanced Efficiency: It's faster for large datasets, as it avoids repeated joins. Improved Readability: Using a temporary table makes the process more modular and easier to understand. Conclusion Eliminating duplicate records is essential for maintaining a well-organized database, improving performance, and ensuring accurate reporting. This guide presented two approaches: Direct Method with GROUP BY and HAVING Clauses: Ideal for small datasets, using self-joins to delete duplicates. Temporary Table Approach: More efficient for larger datasets, leveraging temporary storage to streamline deletion. Choose the method that best fits your data size and complexity to keep your database clean and efficient.
19 November 2024 · 8 min to read
MySQL

Installing MariaDB on Ubuntu 22.04

MariaDB is an open-source relational database management system, which has made it a popular alternative to MySQL. It is often included in LAMP stacks (which consist of Linux, Apache, MySQL, and PHP, sometimes with Python and Perl compilers). This document provides a brief guide to setting up MariaDB. The setup involves three steps: updating the package index, installing the mariadb-server, and activating a security script restricting unauthorized access to the remote host.   The sequence of commands looks like this: sudo apt update sudo apt install mariadb-server sudo mysql_secure_installation For this tutorial, we will use a Hostman cloud server with Ubuntu 22.04 installed. Before diving into this guide, we recommend performing initial setup steps, such as creating a user account with sudo privileges and setting basic UFW firewall rules. Step 1: Installing MariaDB Repositories are regularly updated to include stable versions of utilities. Distributions, on the other hand, include outdated releases that were current at the time of the build, so they need to be updated to avoid compatibility issues. This procedure is executed with the following command: sudo apt update Now we can install the package we need: sudo apt install mariadb-server The installation proceeds without prompting for a password or making any other configuration changes. Using MariaDB in this form on the server is not advisable, as it will operate in an insecure mode. To rectify this situation, we will apply the mysql_secure_installation script that comes with the software. This script will restrict access to the server and eliminate unauthorized accounts. Step 2: Setting Up MariaDB The security script modifies the insecure options that are set by default. For instance, it creates test accounts and allows remote connections using the root account. This potentially poses a risk of hacking and unauthorized access to the information stored in the created database. To run the script, use the following command: sudo mysql_secure_installation This command will initiate a series of prompts that allow you to change the database's security parameters.  The first prompt relates to the root account, and the system will request the password for the active database. Press Enter. This indicates that there is currently no protection. Enter current password for root (enter for none): Switch to unix_socket authentication [Y/n] Enter n and press Enter Change the root password? [Y/n] Enter Y and press Enter. New password: Re-enter new password: Enter and re-enter the new root user password and press Enter. Answer Yes (Y) to all the following prompts. Remove anonymous users? [Y/n] Disallow root login remotely? [Y/n] Remove test database and access to it? [Y/n] Reload privilege tables now? [Y/n] The system will remove the test database and anonymous accounts, disable access through the root account, and load the updated rules.  The installation and configuration of the MariaDB package are complete, and you can now begin using it. Alternatively, you can proceed to an optional step to create an administrator account to enable password access. Step 3: Create an Administrator Account By default, on Ubuntu, MariaDB is installed using the unix_socket plugin, which means that password prompts do not apply. In most cases, this approach provides a high level of security. However, it also complicates administrative tasks, such as those done through phpMyAdmin. When starting or stopping the server or managing logs, the root account is used. That is why we did not change its data. However, during a package update, these settings may change on their own, so it's better to enable password authentication right away. As an example, we will create an account named admin and give it the same privileges as the root account. First, open the MariaDB command line: sudo mariadb Next, create the new user: GRANT ALL ON *.* TO 'admin'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION; Replace admin and password with any preferred combinations.  After creating the account, flush the privileges while keeping the settings in the current session: FLUSH PRIVILEGES; Now you can close the shell: exit; Next, you should test MariaDB to ensure that the settings are correct. Step 4: Diagnostics When the MariaDB is installed from the official repository, it automatically configures the settings to ensure that the MariaDB module starts automatically. However, it's still a good practice to manually check its status: sudo systemctl status mariadb The output on the screen will look something like this: If the utility is not running, you will need to start it manually and also enable the service: sudo systemctl enable mariadb sudo systemctl start mariadb After forcibly starting the service, you can make a test connection to the database using mysqladmin. It allows you to interact with the database with administrative rights, execute commands, and change settings. Here’s an example of connecting and displaying the version number: sudo mysqladmin version The output on the screen will look like this: If access was configured using the administrator password, you can use the command: mysqladmin -u admin -p version The current version output confirms that the database is running and functioning, and that the user has access to its contents. Conclusions We have completed an overview of the installation and configuration for the MariaDB database management system. We discussed methods to protect against unauthorized access to the database and the creation of a new user who will have access to information equal to that of the root user.
07 November 2024 · 5 min to read
MySQL

How to Calculate Age From Date of Birth Using TIMESTAMPDIFF in MySQL

Calculating age from a date of birth (DOB) is a common requirement in many applications. In MySQL, this can be efficiently achieved using the TIMESTAMPDIFF function. This tutorial will guide you through the process of calculating age using TIMESTAMPDIFF, handling edge cases, and integrating the query into applications. Prerequisites Before diving into the tutorial, ensure you have: A MySQL database set up and accessible. Basic knowledge of SQL queries and MySQL functions. A table with a date of birth column to work with. Overview of TIMESTAMPDIFF Function The TIMESTAMPDIFF function calculates the difference between two dates based on the specified unit of time (e.g., years, months, days). For calculating age, you will use TIMESTAMPDIFF to find the difference in years between the current date and the date of birth. TIMESTAMPDIFF(unit, datetime1, datetime2) unit: The unit of time for the result (e.g., YEAR, MONTH, DAY). datetime1: The first date (usually the date of birth). datetime2: The second date (usually the current date). Writing the Basic TIMESTAMPDIFF Query To calculate age from a date of birth, use the following query: SELECT TIMESTAMPDIFF(YEAR, date_of_birth, CURDATE()) AS ageFROM users; In this query: YEAR specifies that the result should be in years. date_of_birth is the column containing the date of birth. CURDATE() returns the current date. Handling Edge Cases When calculating age, consider the following edge cases: Leap Years Leap years do not significantly affect age calculations, as TIMESTAMPDIFF accurately accounts for these in its calculations. Birthdays on February 29 For individuals born on February 29, TIMESTAMPDIFF will handle their age calculation correctly, but be aware of potential issues if you use functions that do not recognize leap years. Different Date Formats Ensure that the date format stored in the database matches MySQL's date format (YYYY-MM-DD). If you encounter format issues, use the STR_TO_DATE function to convert strings to date formats. Practical Examples and Use Cases Here are some practical examples of using TIMESTAMPDIFF: Example 1: Calculate Age for a Specific User SELECT TIMESTAMPDIFF(YEAR, '1990-05-15', CURDATE()) AS age; This query calculates the age of someone born on May 15, 1990. Example 2: Age Calculation for All Users SELECT name, TIMESTAMPDIFF(YEAR, date_of_birth, CURDATE()) AS ageFROM users; This query retrieves names and ages of all users from the users table. Integrating the Query in Applications To integrate this query into an application: In a PHP Application: $query = "SELECT TIMESTAMPDIFF(YEAR, date_of_birth, CURDATE()) AS age FROM users";$result = mysqli_query($conn, $query); In a Python Application:  query = "SELECT TIMESTAMPDIFF(YEAR, date_of_birth, CURDATE()) AS age FROM users"  cursor.execute(query) Ensure that your application handles database connections securely and efficiently. Performance Considerations The TIMESTAMPDIFF function is optimized for performance, but be mindful of the following: Indexes: Ensure that the date_of_birth column is indexed to speed up queries. Query Optimization: For large datasets, consider optimizing queries to improve performance. Troubleshooting Common Issues Here are some common issues and their solutions: Incorrect Results Issue: Age calculation is incorrect. Solution: Ensure that dates are correctly formatted and the date_of_birth column contains valid date values. Query Errors Issue: Syntax or execution errors. Solution: Verify that the SQL syntax is correct and that you are using valid MySQL functions. Conclusion Calculating age from a date of birth using TIMESTAMPDIFF in MySQL is straightforward and efficient. By following the steps outlined in this tutorial, you can accurately determine age and handle various edge cases. Integrate these calculations into your applications and optimize performance for the best results.
10 September 2024 · 4 min to read

Do you have questions,
comments, or concerns?

Our professionals are available to assist you at any moment,
whether you need help or are just unsure of where to start.
Email us
Hostman's Support