SHOW DATABASES;Example: A fast way to confirm what databases are available after connecting.
Gotcha: Results depend on the permissions of the current user.
This page focuses on the MySQL tasks developers reach for most often while debugging, checking data, and exploring schemas.
SHOW DATABASES;Example: A fast way to confirm what databases are available after connecting.
Gotcha: Results depend on the permissions of the current user.
USE coderstool;Example: Useful when you have just connected and need to move into the schema you want to inspect.
Gotcha: This changes the default database for the current session only.
SHOW TABLES;Example: Useful for confirming table names before querying or debugging migrations.
Gotcha: Run `USE your_database;` first or connect directly to the target database.
DESCRIBE users;Example: A fast way to inspect columns, types, nullability, and keys.
Gotcha: `SHOW CREATE TABLE users;` is better when you also need indexes, engine details, or the exact table definition.
SELECT * FROM users LIMIT 10;Example: Useful for quick inspection without pulling the full table.
Gotcha: Add `ORDER BY` if you need deterministic results.
MySQL work is often repetitive in the best possible way. You list databases, inspect tables, describe columns, run filters, add indexes, and define foreign-key rules. The value of a reference page is not to cover every corner of the MySQL Reference Manual. It is to keep the commands you actually need near the top of your workflow.
This page focuses on practical MySQL tasks: connecting the language of everyday SQL to the operational questions that come up in development. If you searched for MySQL query documentation, MySQL reference manual, MySQL reference download, or examples of the REFERENCES keyword, the useful layer is usually the concrete pattern, not a long theoretical explanation.
| Task | Statement | Why it helps |
|---|---|---|
| List databases | SHOW DATABASES; |
Quick environment check |
| Pick a database | USE app_db; |
Sets context for the session |
| List tables | SHOW TABLES; |
Confirms what exists |
| Describe columns | DESCRIBE users; |
Data types, nullability, keys |
| Preview data | SELECT * FROM users LIMIT 20; |
Inspect real rows safely |
| Filter with ordering | SELECT * FROM orders WHERE status='paid' ORDER BY created_at DESC; |
Common operational query shape |
| Create an index | CREATE INDEX idx_orders_created_at ON orders(created_at); |
Speeds common filters |
| Define a foreign key | REFERENCES users(id) |
Expresses relational integrity |
```sql
SHOW DATABASES;
USE app_db;
SHOW TABLES;
DESCRIBE orders;
SELECT id, customerid, status, createdat
FROM orders
WHERE status = 'paid'
ORDER BY created_at DESC
LIMIT 25;
```
This is the right rhythm for most MySQL sessions. First understand the environment, then inspect the schema, then query with a narrow result set. It is tempting to jump directly into a join or an update, but inspection first is the habit that keeps SQL safe and fast.
REFERENCES means in MySQLIn MySQL, REFERENCES appears when you define a foreign key relationship. In practical terms, it says that a column in one table must point to a valid row in another table. That is the relational backbone of many applications: orders reference customers, comments reference posts, and line items reference invoices.
```sql
CREATE TABLE orders (
id BIGINT PRIMARY KEY,
customer_id BIGINT NOT NULL,
created_at DATETIME NOT NULL,
CONSTRAINT fkorderscustomer
FOREIGN KEY (customer_id)
REFERENCES customers(id)
ON DELETE RESTRICT
);
```
When developers ask “what is a reference in MySQL?” this is usually the answer they need. It is not just documentation language; it is the actual rule that protects relationships between tables.
A reference page should help you switch mental modes cleanly. Querying asks, “what rows do I need?” Schema design asks, “how should this data behave over time?” MySQL makes both look like SQL, but the jobs are different.
For querying, focus on SELECT, WHERE, JOIN, GROUP BY, and indexes that match access patterns. For schema design, focus on types, nullability, primary keys, unique constraints, and foreign-key actions such as ON DELETE CASCADE or RESTRICT. That distinction reduces many avoidable design mistakes.
When someone asks “which DB uses 3306?”, the practical answer is that 3306 is the default TCP port commonly associated with MySQL. In real environments it can be changed, but it is the standard expectation in many local development setups, clients, and documentation examples.
Another common question is “what are the four types of MySQL?” People often mean different things by that phrase: editions, deployment styles, or storage engines. In daily developer work, the more useful framing is not a fixed number of “types,” but understanding which engine, version, and operational constraints your environment actually uses.
| Mistake | Why it hurts | Better move |
|---|---|---|
| Querying before inspecting tables | You guess column names and types | SHOW TABLES and DESCRIBE first |
Running wide SELECT * in large tables |
Slow and noisy | Select only needed columns with LIMIT while exploring |
| Defining foreign keys without indexes | Can hurt write and lookup behavior | Align indexes with relational access patterns |
| Confusing MySQL syntax with PostgreSQL or another dialect | Small differences add up | Keep a MySQL-specific reference nearby |
Most often it means a foreign-key relationship declared with REFERENCES, where one table points to a valid row in another table.
MySQL commonly uses TCP port 3306 by default, though deployments can customize it.
They may mean editions, storage engines, or deployment patterns. In practice, developers usually need to know the exact version and engine behavior rather than a simplified count.
REFERENCES keyword in MySQL?Use it in a foreign-key definition to bind one column to a referenced column, typically a primary key in another table.
Pair this page with the Postgres reference for PostgreSQL-specific SQL and psql habits, the Git reference when schema files live inside version control, the Bash reference for command-line database workflows, or the Developer Reference Hub for adjacent syntax pages.
I think it’s a new feature. Don’t tell anyone it was an accident.
…
…