1. What is a Storage Engine in MySQL?
A storage engine in MySQL determines how data is stored, accessed, and managed internally.
- Every table in MySQL uses a storage engine.
- The storage engine defines features, performance, and behavior of the table.
Common storage engines:
Engine | Supports Transactions? | Supports Foreign Keys? | Locking Type | Notes |
---|---|---|---|---|
InnoDB | ✅ Yes | ✅ Yes | Row-level | Default in modern MySQL, crash-safe, best for concurrent writes |
MyISAM | ❌ No | ❌ No | Table-level | Older engine, read-heavy workloads, no transactions |
2. ENGINE=InnoDB Explained
When you create a table:
CREATE TABLE test_scripts_t (
script_id BIGINT AUTO_INCREMENT PRIMARY KEY,
script_name VARCHAR(255) NOT NULL
) ENGINE=InnoDB;
-
ENGINE=InnoDB
tells MySQL to use InnoDB storage engine for this table. - Benefits:
-
Transactions – all-or-nothing operations (
START TRANSACTION
,COMMIT
,ROLLBACK
) - Foreign keys – enforce relational integrity
- Row-level locking – allows multiple scripts to insert/update simultaneously
- Crash safety – automatic recovery if MySQL crashes
2.1 What happens if you don’t specify ENGINE?
- MySQL uses its default engine (check with
SHOW ENGINES;
). - Modern MySQL → default is usually InnoDB → everything works.
- Old MySQL → default may be MyISAM → you lose transactions and foreign key support.
Example problem if default is MyISAM:
- You define a foreign key, but it is ignored.
- You try
ROLLBACK
after a failure → MySQL does nothing. - Multiple concurrent inserts may block each other (table-level locking).
3. Transactions (Beginner-Friendly)
A transaction is a set of SQL statements executed as a single unit:
- Either all succeed → changes saved (
COMMIT
) - Or any fail → all undone (
ROLLBACK
)
3.1 Example: Bank Transfer
Tables:
CREATE TABLE accounts (
id INT PRIMARY KEY,
name VARCHAR(50),
balance INT
) ENGINE=InnoDB;
Transaction to transfer $100 from Alice to Bob:
START TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE name='Alice';
UPDATE accounts SET balance = balance + 100 WHERE name='Bob';
COMMIT;
- ✅ Both updates succeed → transfer completed
- ❌ If Bob’s row is missing →
ROLLBACK
→ Alice’s balance remains unchanged
Important: Transactions only work with InnoDB.
4. Foreign Keys (FK)
A foreign key is a column that links one table to another, ensuring relational integrity.
- Example:
orders
table hasuser_id
referencingusers.user_id
- Prevents creating orphan records (e.g., orders for non-existent users)
4.1 Example: Users and Orders
Users table:
CREATE TABLE users (
user_id INT PRIMARY KEY,
name VARCHAR(50),
email VARCHAR(100)
) ENGINE=InnoDB;
Orders table with FK:
CREATE TABLE orders (
order_id INT PRIMARY KEY,
user_id INT,
product VARCHAR(50),
amount INT,
FOREIGN KEY (user_id) REFERENCES users(user_id)
ON DELETE CASCADE
) ENGINE=InnoDB;
-
ON DELETE CASCADE
→ deletes orders automatically if user is deleted - You cannot insert an order with a
user_id
that doesn’t exist inusers
4.2 Foreign Key in Action
- Insert valid data:
INSERT INTO users (user_id, name, email) VALUES (1, 'Alice', 'alice@mail.com');
INSERT INTO orders (order_id, user_id, product, amount) VALUES (101, 1, 'Laptop', 1200);
✅ Works fine.
- Insert invalid data:
INSERT INTO orders (order_id, user_id, product, amount) VALUES (102, 99, 'Phone', 500);
❌ Error! user_id = 99
does not exist.
- Delete a user:
DELETE FROM users WHERE user_id = 1;
- Because of
ON DELETE CASCADE
, Alice’s order is also deleted automatically.
4.3 What if not using InnoDB?
- MyISAM ignores foreign key definitions
- You can insert orphan rows without error
- No cascading delete → manual cleanup required
5. Beginner Analogy
Concept | Analogy |
---|---|
Transaction | Writing multiple entries in a notebook with erasable ink → undo if mistake |
Foreign Key | Linking an order to a valid user ID card → cannot create an order for a fake user |
InnoDB | Notebook with erasable ink, checks all references automatically |
MyISAM | Permanent ink → mistakes cannot be undone, references not checked |
✅ Key Takeaways for Beginners
- Always use InnoDB unless you have a very specific reason.
- Transactions allow safe, all-or-nothing operations.
- Foreign keys enforce data integrity across tables.
- MyISAM or non-InnoDB tables cannot use FK or transactions.
- For logging automation test executions, InnoDB + FK + transactions is the safe design.
Top comments (0)