How to Add a Table to a Database in MySQL/MariaDB (Two Easy Ways)

25 June 2026
by: Felix Aubert
in: MySQL/MariaDB
Tags: create table, database tutorial, MariaDB, MySQL, phpMyAdmin
note: no comments

So you have a database sitting there, empty, and now you need to actually put some structure into it. A database without tables is like a filing cabinet with no folders. In this tutorial I’ll walk you through exactly how to add a table to a database in MySQL or MariaDB, two different ways: by writing a `CREATE TABLE` statement yourself, and by clicking through the phpMyAdmin graphical interface. No prior table-building experience required. We’ll run real commands, look at the output together, and verify everything worked.

Table of Contents

Key Takeaways
• You add a table to a database with the `CREATE TABLE` SQL statement, or visually through the phpMyAdmin GUI.
• Every column needs a data type (`INT`, `VARCHAR`, `DATE`, etc.) that defines and enforces what it can hold.
• Almost every table should have a PRIMARY KEY — usually an `AUTO_INCREMENT` integer `id`.
• Constraints like `NOT NULL`, `UNIQUE`, and `DEFAULT` make the database protect your data automatically.
• Verify your work with `SHOW TABLES;` and `DESCRIBE tablename;`.

What do you need before you start?

You only need two things: a database that already exists, and a way to talk to it. That “way” is either the `mysql` command-line client (the terminal) or phpMyAdmin (a web-based GUI that ships with most hosting control panels). Both connect to the exact same MySQL/MariaDB server, so the table you create in one shows up in the other. Pick whichever feels comfortable.

For the examples below, I’ll assume you already have a database named `myapp`. If you’re in the CLI, select it first:

“`sql USE myapp; “`

You should see a short confirmation: `Database changed`. Now we’re working *inside* that database, and any table we create lands there.

How do you add a table with SQL (CREATE TABLE)?

The most direct, repeatable way to add a table is the `CREATE TABLE` statement. Here’s a complete, real-world example — a `users` table. Type it into the `mysql` prompt (or paste it into phpMyAdmin’s SQL tab) and run it:

“`sql CREATE TABLE users ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100) NOT NULL, email VARCHAR(255) UNIQUE, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); “`

Run it, and you should see something like:

“` Query OK, 0 rows affected (0.03 sec) “`

That’s it — the table now exists. But let’s slow down and unpack that statement line by line, because every piece is doing real work.

Choosing your columns and data types

A table is just a set of columns, and each column holds one kind of information. The word right after each column name is its data type, and the data type is the most important decision you’ll make. Here are the ones you’ll reach for constantly:

Data type	Use it for	Example
`INT`	Whole numbers (IDs, counts, quantities)	`42`, `1000`
`VARCHAR(n)`	Short text up to n characters	`’Felix Aubert’`
`TEXT`	Long text (articles, comments, bios)	a paragraph
`DATE`	A calendar date only	`’2026-06-27’`
`DATETIME`	A date and time, as entered	`’2026-06-27 14:30:00’`
`TIMESTAMP`	A point in time (auto-updates available)	`CURRENT_TIMESTAMP`
`DECIMAL(m,d)`	Exact decimals — money, prices	`DECIMAL(10,2)` → `19.99`
`BOOLEAN` / `TINYINT(1)`	True/false flags	`1` (true), `0` (false)

In our `users` table, `name` is a `VARCHAR(100)` (text capped at 100 characters), `email` is a `VARCHAR(255)`, and `created_at` is a `TIMESTAMP`. The `id` is an `INT`. Each type tells MySQL precisely what’s allowed in that column.

What is a PRIMARY KEY?

A PRIMARY KEY is the column that uniquely identifies each row. No two rows can share the same primary key value, and it can never be empty. The standard pattern — the one you’ll use 90% of the time — is an integer `id` marked `AUTO_INCREMENT`:

“`sql id INT AUTO_INCREMENT PRIMARY KEY “`

`AUTO_INCREMENT` means you never have to supply the `id` yourself. Insert a row, and MySQL hands out the next number automatically: 1, 2, 3, and so on. This gives every row a permanent, unique handle you can use to reference it later.

Adding constraints (NOT NULL, UNIQUE, DEFAULT)

Constraints are rules the database enforces for you. Look back at the example:

`NOT NULL` on `name` means a user *must* have a name — try to insert a row without one and MySQL rejects it.
`UNIQUE` on `email` means no two users can have the same email address. Attempt a duplicate and you get an error, not a silent mess.
`DEFAULT CURRENT_TIMESTAMP` on `created_at` means if you don’t supply a value, MySQL fills in the current date and time automatically.

These three little keywords do an enormous amount of work. They mean your *application code* doesn’t have to police data quality — the database does it at the source.

The decision that matters most

Here’s the thing most beginners rush past: the single most important decision when adding a table is choosing the right data type for each column. It’s tempting to make everything a loose `TEXT` field “to be safe,” but that throws away the database’s superpower. A data type isn’t just about storage — it’s about *enforcement*. An `INT` column flat-out rejects text. A `DATE` column rejects “garbage” dates like `’2026-13-45’`. A `VARCHAR(100)` caps the length so nobody slips a 10,000-character string into a name field. A `UNIQUE` constraint blocks duplicates before they exist. Get the types and constraints right at `CREATE TABLE` time, and the database protects your data integrity automatically, forever, with zero extra code. Spend the thirty seconds to pick proper types instead of dumping everything into `TEXT` — it’s the cheapest insurance you’ll ever buy.

How do you add a table with the phpMyAdmin GUI (no SQL)?

Not comfortable writing SQL yet? No problem. phpMyAdmin lets you build the exact same table by clicking. Here’s the flow:

Log in to phpMyAdmin (usually a button inside your hosting control panel).
In the left sidebar, click your database — for us, `myapp`. The center panel updates to show that database.
Find the “Create table” form. Enter a name (`users`) and the number of columns (we need 4), then click Go.
Now you get a row of fields for each column. For each one, fill in:

Name — `id`, `name`, `email`, `created_at`
Type — pick from the dropdown: `INT`, `VARCHAR`, `TIMESTAMP`, etc.
Length/Values — e.g. `100` for the `VARCHAR(100)` name column
Attributes / Index — set `id` as the PRIMARY index and tick A_I (auto-increment); set `email` to a UNIQUE index; tick Null off where you want `NOT NULL`
Default — choose `CURRENT_TIMESTAMP` for `created_at`

Click Save.

phpMyAdmin shows a green success message, and — this is the nice part — it prints the exact `CREATE TABLE` SQL it just generated. Reading that generated SQL is honestly one of the best ways to *learn* the syntax. The GUI and the SQL produce an identical result; they’re just two doors into the same room.

How do you verify the table was created?

Never assume — always check. Back in the `mysql` CLI, list every table in the current database:

“`sql SHOW TABLES; “`

Output:

“` +——————+

| Tables_in_myapp | +——————+

| users | +——————+ 1 row in set (0.00 sec) “`

There’s our `users` table. Now let’s inspect its structure to confirm the columns and types landed correctly:

“`sql DESCRIBE users; “`

“` +————+————–+——+—–+——————-+—————-+

| id | int | NO | PRI | NULL | auto_increment |

Read that table top to bottom and you can see everything worked: `id` is the primary key (`PRI`) with `auto_increment`, `email` carries a `UNI` (unique) key, `name` is `NOT NULL`, and `created_at` defaults to the current timestamp. In phpMyAdmin you’d see the same breakdown by clicking the table’s Structure tab.

What are the best practices for adding tables?

A few habits will save you real headaches down the road:

Pick the smallest appropriate type and size. Don’t use `TEXT` for a 50-character name, and don’t use `BIGINT` where `INT` will do. Right-sizing keeps the table fast and lean.
Always include a primary key. Tables without one are hard to update, join, and reference reliably. An `AUTO_INCREMENT` integer `id` is the safe default.
Name things clearly and consistently. Use lowercase, descriptive names — `created_at`, not `dt2`. Future-you will be grateful.
Add constraints early. It’s far easier to start with `NOT NULL` and `UNIQUE` in place than to clean up bad data later.
Keep one table for one concept. Users in a `users` table, orders in `orders`. Mixing concerns into one giant table gets painful fast.

DarazHost hosting includes MySQL/MariaDB databases with phpMyAdmin built in, so you can do everything in this tutorial right out of the box. Create tables visually with no SQL needed, or open the SQL tab and run `CREATE TABLE` directly — your choice. Manage your entire database from one friendly dashboard, with automatic backups protecting your data so a wrong click never costs you. With reliable database hosting, SSD speed, and 24/7 support, DarazHost gives your tables a solid place to live.

Once your table exists, the natural next step is putting data into it. And if your needs change, you don’t have to start over — you can adjust an existing table with `ALTER TABLE`.

Frequently Asked Questions

Do I need to create a database before I can add a table?

Yes. Tables live *inside* databases, so the database must exist first. Create one with `CREATE DATABASE myapp;`, then `USE myapp;` to select it, and finally run your `CREATE TABLE` statement. In phpMyAdmin you’d create the database from the Databases tab before the Create table form appears.

What happens if I try to create a table that already exists?

MySQL throws an error: `Table ‘users’ already exists`. To avoid it in scripts, use `CREATE TABLE IF NOT EXISTS users (…)` — that quietly skips creation if the table is already there instead of failing.

Can I add a table without setting a primary key?

Technically yes, MySQL will let you. But it’s strongly discouraged. Without a primary key, individual rows are hard to update or reference uniquely, and performance suffers on larger tables. Add an `AUTO_INCREMENT` integer `id` unless you have a very specific reason not to.

What’s the difference between VARCHAR and TEXT?

`VARCHAR(n)` is for shorter strings with a defined maximum length (up to 65,535 characters total per row across columns) and can be indexed easily — ideal for names, emails, and titles. `TEXT` is for long-form content like articles or comments and has looser indexing. Rule of thumb: use `VARCHAR` when you know a sensible length cap, `TEXT` when you genuinely don’t.

Is phpMyAdmin or the SQL command line better for beginners?

For your very first tables, phpMyAdmin is friendlier — the visual form prevents syntax errors and even shows you the SQL it generates, which doubles as a learning tool. As you grow, the `CREATE TABLE` statement becomes faster and is easy to save, share, and version-control. Most developers end up using both.